--- mstools/h/winbase.h 2018/08/09 18:20:01 1.1.1.1 +++ mstools/h/winbase.h 2018/08/09 18:23:04 1.1.1.4 @@ -21,6 +21,10 @@ Revision History: #ifndef _WINBASE_ #define _WINBASE_ +#ifdef __cplusplus +extern "C" { +#endif + /* * Compatability macros */ @@ -30,38 +34,67 @@ Revision History: #define SetSwapAreaSize(w) (w) #define LockSegment(w) GlobalFix((HANDLE)(w)) #define UnlockSegment(w) GlobalUnfix((HANDLE)(w)) +#define GetCurrentTime() GetTickCount() #define Yield() #define INVALID_HANDLE_VALUE (HANDLE)-1 +#define INVALID_FILE_SIZE (DWORD)0xFFFFFFFF + #define FILE_BEGIN 0 #define FILE_CURRENT 1 #define FILE_END 2 -#define FILE_ATTRIBUTE_DIRECTORY 0x00000010 +#define TIME_ZONE_ID_INVALID (DWORD)0xFFFFFFFF + +#define WAIT_FAILED (DWORD)0xFFFFFFFF #define WAIT_OBJECT_0 ((STATUS_WAIT_0 ) + 0 ) #define WAIT_ABANDONED ((STATUS_ABANDONED_WAIT_0 ) + 0 ) #define WAIT_ABANDONED_0 ((STATUS_ABANDONED_WAIT_0 ) + 0 ) #define WAIT_TIMEOUT STATUS_TIMEOUT +#define WAIT_IO_COMPLETION STATUS_USER_APC #define STILL_ACTIVE STATUS_PENDING #define EXCEPTION_ACCESS_VIOLATION STATUS_ACCESS_VIOLATION #define EXCEPTION_DATATYPE_MISALIGNMENT STATUS_DATATYPE_MISALIGNMENT #define EXCEPTION_BREAKPOINT STATUS_BREAKPOINT #define EXCEPTION_SINGLE_STEP STATUS_SINGLE_STEP +#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED STATUS_ARRAY_BOUNDS_EXCEEDED +#define EXCEPTION_FLT_DENORMAL_OPERAND STATUS_FLOAT_DENORMAL_OPERAND +#define EXCEPTION_FLT_DIVIDE_BY_ZERO STATUS_FLOAT_DIVIDE_BY_ZERO +#define EXCEPTION_FLT_INEXACT_RESULT STATUS_FLOAT_INEXACT_RESULT +#define EXCEPTION_FLT_INVALID_OPERATION STATUS_FLOAT_INVALID_OPERATION +#define EXCEPTION_FLT_OVERFLOW STATUS_FLOAT_OVERFLOW +#define EXCEPTION_FLT_STACK_CHECK STATUS_FLOAT_STACK_CHECK +#define EXCEPTION_FLT_UNDERFLOW STATUS_FLOAT_UNDERFLOW +#define EXCEPTION_INT_DIVIDE_BY_ZERO STATUS_INTEGER_DIVIDE_BY_ZERO +#define EXCEPTION_INT_OVERFLOW STATUS_INTEGER_OVERFLOW +#define EXCEPTION_PRIV_INSTRUCTION STATUS_PRIVILEGED_INSTRUCTION +#define EXCEPTION_IN_PAGE_ERROR STATUS_IN_PAGE_ERROR +#define EXCEPTION_ILLEGAL_INSTRUCTION STATUS_ILLEGAL_INSTRUCTION +#define EXCEPTION_NONCONTINUABLE_EXCEPTION STATUS_NONCONTINUABLE_EXCEPTION +#define EXCEPTION_STACK_OVERFLOW STATUS_STACK_OVERFLOW +#define EXCEPTION_INVALID_DISPOSITION STATUS_INVALID_DISPOSITION #define CONTROL_C_EXIT STATUS_CONTROL_C_EXIT +#define MoveMemory RtlMoveMemory +#define CopyMemory RtlCopyMemory +#define FillMemory RtlFillMemory +#define ZeroMemory RtlZeroMemory // -// File creation flags must start in second byte since they +// File creation flags must start at the high end since they // are combined with the attributes // -#define FILE_FLAG_WRITE_THROUGH 0x00000100 -#define FILE_FLAG_OVERLAPPED 0x00000200 -#define FILE_FLAG_NO_BUFFERING 0x00000400 -#define FILE_FLAG_RANDOM_ACCESS 0x00000800 -#define FILE_FLAG_SEQUENTIAL_SCAN 0x00001000 +#define FILE_FLAG_WRITE_THROUGH 0x80000000 +#define FILE_FLAG_OVERLAPPED 0x40000000 +#define FILE_FLAG_NO_BUFFERING 0x20000000 +#define FILE_FLAG_RANDOM_ACCESS 0x10000000 +#define FILE_FLAG_SEQUENTIAL_SCAN 0x08000000 +#define FILE_FLAG_DELETE_ON_CLOSE 0x04000000 +#define FILE_FLAG_BACKUP_SEMANTICS 0x02000000 +#define FILE_FLAG_POSIX_SEMANTICS 0x01000000 #define CREATE_NEW 1 #define CREATE_ALWAYS 2 @@ -107,29 +140,20 @@ Revision History: #define PIPE_UNLIMITED_INSTANCES 255 // -// Special values for mailslot information. -// - -// -// Special value for NextMessageSize to indicate that there is no next -// message. -// - -#define MAILSLOT_NO_MESSAGE -1 - -// -// Special value for mailslot size creation to indicate that the system -// should choose the size of the mailslot buffer. +// Define the Security Quality of Service bits to be passed +// into CreateFile // -#define MAILSLOT_SIZE_AUTO 0 +#define SECURITY_ANONYMOUS ( SecurityAnonymous << 16 ) +#define SECURITY_IDENTIFICATION ( SecurityIdentification << 16 ) +#define SECURITY_IMPERSONATION ( SecurityImpersonation << 16 ) +#define SECURITY_DELEGATION ( SecurityDelegation << 16 ) -// -// Special value for read timeout to indicate that mailslot reads should -// never timeout. -// +#define SECURITY_CONTEXT_TRACKING 0x00040000 +#define SECURITY_EFFECTIVE_ONLY 0x00080000 -#define MAILSLOT_WAIT_FOREVER -1 +#define SECURITY_SQOS_PRESENT 0x00100000 +#define SECURITY_VALID_SQOS_FLAGS 0x001F0000 // // File structures @@ -180,7 +204,7 @@ typedef struct _SYSTEMTIME { WORD wMilliseconds; } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME; -typedef DWORD (*PTHREAD_START_ROUTINE)( +typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)( LPVOID lpThreadParameter ); typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; @@ -189,7 +213,11 @@ typedef RTL_CRITICAL_SECTION CRITICAL_SE typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION; typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION; -#ifdef i386 +typedef RTL_CRITICAL_SECTION_DEBUG CRITICAL_SECTION_DEBUG; +typedef PRTL_CRITICAL_SECTION_DEBUG PCRITICAL_SECTION_DEBUG; +typedef PRTL_CRITICAL_SECTION_DEBUG LPCRITICAL_SECTION_DEBUG; + +#ifdef _X86_ typedef PLDT_ENTRY LPLDT_ENTRY; #else typedef LPVOID LPLDT_ENTRY; @@ -199,19 +227,43 @@ typedef LPVOID LPLDT_ENTRY; #define MUTEX_ALL_ACCESS MUTANT_ALL_ACCESS // +// Serial provider type. +// + +#define SP_SERIALCOMM ((DWORD)0x00000001) + +// +// Provider SubTypes +// + +#define PST_UNSPECIFIED ((DWORD)0x00000000) +#define PST_RS232 ((DWORD)0x00000001) +#define PST_PARALLELPORT ((DWORD)0x00000002) +#define PST_RS422 ((DWORD)0x00000003) +#define PST_RS423 ((DWORD)0x00000004) +#define PST_RS449 ((DWORD)0x00000005) +#define PST_FAX ((DWORD)0x00000021) +#define PST_SCANNER ((DWORD)0x00000022) +#define PST_NETWORK_BRIDGE ((DWORD)0x00000100) +#define PST_LAT ((DWORD)0x00000101) +#define PST_TCPIP_TELNET ((DWORD)0x00000102) +#define PST_X25 ((DWORD)0x00000103) + + +// // Provider capabilities flags. // -#define PCF_DTRDTS ((DWORD)0x0001) -#define PCF_RTSCTS ((DWORD)0x0002) -#define PCF_CD ((DWORD)0x0004) -#define PCF_PARITY_CHECK ((DWORD)0x0008) -#define PCF_XONXOFF ((DWORD)0x0010) -#define PCF_SETXCHAR ((DWORD)0x0020) -#define PCF_TOTTIMEOUTS ((DWORD)0x0040) -#define PCF_INTTIMEOUTS ((DWORD)0x0080) -#define PCF_SPECIALCHARS ((DWORD)0x0100) -#define PCF_16BITMODE ((DWORD)0x0200) +#define PCF_DTRDSR ((DWORD)0x0001) +#define PCF_RTSCTS ((DWORD)0x0002) +#define PCF_RLSD ((DWORD)0x0004) +#define PCF_PARITY_CHECK ((DWORD)0x0008) +#define PCF_XONXOFF ((DWORD)0x0010) +#define PCF_SETXCHAR ((DWORD)0x0020) +#define PCF_TOTALTIMEOUTS ((DWORD)0x0040) +#define PCF_INTTIMEOUTS ((DWORD)0x0080) +#define PCF_SPECIALCHARS ((DWORD)0x0100) +#define PCF_16BITMODE ((DWORD)0x0200) // // Comm provider settable parameters. @@ -223,7 +275,7 @@ typedef LPVOID LPLDT_ENTRY; #define SP_STOPBITS ((DWORD)0x0008) #define SP_HANDSHAKING ((DWORD)0x0010) #define SP_PARITY_CHECK ((DWORD)0x0020) -#define SP_CARRIER_DETECT ((DWORD)0x0040) +#define SP_RLSD ((DWORD)0x0040) // // Settable baud rates in the provider. @@ -245,6 +297,9 @@ typedef LPVOID LPLDT_ENTRY; #define BAUD_19200 ((DWORD)0x00002000) #define BAUD_38400 ((DWORD)0x00004000) #define BAUD_56K ((DWORD)0x00008000) +#define BAUD_128K ((DWORD)0x00010000) +#define BAUD_115200 ((DWORD)0x00020000) +#define BAUD_57600 ((DWORD)0x00040000) #define BAUD_USER ((DWORD)0x10000000) // @@ -275,15 +330,10 @@ typedef struct _COMMPROP { WORD wPacketLength; WORD wPacketVersion; DWORD dwServiceMask; - DWORD dwMaxConfigData; + DWORD dwReserved1; DWORD dwMaxTxQueue; DWORD dwMaxRxQueue; DWORD dwMaxBaud; - DWORD dwDefTxQueue; - DWORD dwDefRxQueue; - DWORD dwDefBaud; - WORD wDefDataBits; - WORD wDefStopParity; DWORD dwProvSubType; DWORD dwProvCapabilities; DWORD dwSettableParams; @@ -294,7 +344,7 @@ typedef struct _COMMPROP { DWORD dwCurrentRxQueue; DWORD dwProvSpec1; DWORD dwProvSpec2; - WCHAR ProvChar[1]; + WCHAR wcProvChar[1]; } COMMPROP,*LPCOMMPROP; typedef struct _COMSTAT { @@ -305,7 +355,7 @@ typedef struct _COMSTAT { DWORD fXoffSent : 1; DWORD fEof : 1; DWORD fTxim : 1; - DWORD fReserved : 17; + DWORD fReserved : 25; DWORD cbInQue; DWORD cbOutQue; } COMSTAT, *LPCOMSTAT; @@ -323,6 +373,7 @@ typedef struct _COMSTAT { #define RTS_CONTROL_DISABLE 0x00 #define RTS_CONTROL_ENABLE 0x01 #define RTS_CONTROL_HANDSHAKE 0x02 +#define RTS_CONTROL_TOGGLE 0x03 typedef struct _DCB { DWORD DCBlength; /* sizeof(DCB) */ @@ -332,14 +383,16 @@ typedef struct _DCB { DWORD fOutxCtsFlow:1; /* CTS handshaking on output */ DWORD fOutxDsrFlow:1; /* DSR handshaking on output */ DWORD fDtrControl:2; /* DTR Flow control */ - DWORD fDummy: 2; /* Reserved */ + DWORD fDsrSensitivity:1; /* DSR Sensitivity */ + DWORD fTXContinueOnXoff: 1; /* Continue TX when Xoff sent */ DWORD fOutX: 1; /* Enable output X-ON/X-OFF */ DWORD fInX: 1; /* Enable input X-ON/X-OFF */ - DWORD fPeChar: 1; /* Enable Parity Err Replacement */ + DWORD fErrorChar: 1; /* Enable Err Replacement */ DWORD fNull: 1; /* Enable Null stripping */ DWORD fRtsControl:2; /* Rts Flow control */ - DWORD fDummy2:2; /* Reserved */ - WORD TxDelay; /* Amount of time between chars */ + DWORD fAbortOnError:1; /* Abort all reads and writes on Error */ + DWORD fDummy2:17; /* Reserved */ + WORD wReserved; /* Not currently used */ WORD XonLim; /* Transmit X-ON threshold */ WORD XoffLim; /* Transmit X-OFF threshold */ BYTE ByteSize; /* Number of bits/byte, 4-8 */ @@ -347,7 +400,7 @@ typedef struct _DCB { BYTE StopBits; /* 0,1,2 = 1, 1.5, 2 */ char XonChar; /* Tx and Rx X-ON character */ char XoffChar; /* Tx and Rx X-OFF character */ - char PeChar; /* Parity error replacement char */ + char ErrorChar; /* Error replacement char */ char EofChar; /* End of Input character */ char EvtChar; /* Recieved Event character */ } DCB, *LPDCB; @@ -368,13 +421,13 @@ typedef struct _SYSTEM_INFO { DWORD dwActiveProcessorMask; DWORD dwNumberOfProcessors; DWORD dwProcessorType; - DWORD dwProcessorRevision; - DWORD dwProcessorOptions; + DWORD dwAllocationGranularity; + DWORD dwReserved; } SYSTEM_INFO, *LPSYSTEM_INFO; #define FreeModule(hLibModule) FreeLibrary((hLibModule)) #define MakeProcInstance(lpProc,hInstance) (lpProc) -#define FreeProcInstance(lpProc) +#define FreeProcInstance(lpProc) (lpProc) /* Global Memory Flags */ #define GMEM_FIXED 0x0000 @@ -395,14 +448,9 @@ typedef struct _SYSTEM_INFO { #define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT) #define GPTR (GMEM_FIXED | GMEM_ZEROINIT) -#define GlobalDiscard( h ) (HANDLE)(h) -#define GlobalLRUNewest( h ) (HANDLE)(h) -#define GlobalLRUOldest( h ) (HANDLE)(h) -#define GlobalCompact( dw ) (0x100000L) -#define GlobalFix( h ) (h) -#define GlobalUnfix( h ) ((BOOL)h) -#define GlobalUnWire( h ) (TRUE) -#define GlobalWire( h ) (LPSTR)(h) +#define GlobalLRUNewest( h ) (HANDLE)(h) +#define GlobalLRUOldest( h ) (HANDLE)(h) +#define GlobalDiscard( h ) GlobalReAlloc( (h), 0, GMEM_MOVEABLE ) /* Flags returned by GlobalFlags (in addition to GMEM_DISCARDABLE) */ #define GMEM_DISCARDED 0x4000 @@ -436,9 +484,7 @@ typedef struct _MEMORYSTATUS { #define NONZEROLHND (LMEM_MOVEABLE) #define NONZEROLPTR (LMEM_FIXED) -#define LocalShrink( h, n ) (0x10000) -#define LocalCompact( h ) (0x10000) -#define LocalDiscard( h ) (NULL) +#define LocalDiscard( h ) LocalReAlloc( (h), 0, LMEM_MOVEABLE ) /* Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE) */ #define LMEM_DISCARDED 0x4000 @@ -457,6 +503,15 @@ typedef struct _MEMORYSTATUS { #define CREATE_NEW_CONSOLE 0x00000010 +#define NORMAL_PRIORITY_CLASS 0x00000020 +#define IDLE_PRIORITY_CLASS 0x00000040 +#define HIGH_PRIORITY_CLASS 0x00000080 +#define REALTIME_PRIORITY_CLASS 0x00000100 + +#define CREATE_NEW_PROCESS_GROUP 0x00000200 + +#define CREATE_NO_WINDOW 0x08000000 + #define PROFILE_USER 0x10000000 #define PROFILE_KERNEL 0x20000000 #define PROFILE_SERVER 0x40000000 @@ -468,6 +523,9 @@ typedef struct _MEMORYSTATUS { #define THREAD_PRIORITY_ABOVE_NORMAL (THREAD_PRIORITY_HIGHEST-1) #define THREAD_PRIORITY_ERROR_RETURN (MAXLONG) +#define THREAD_PRIORITY_TIME_CRITICAL THREAD_BASE_PRIORITY_LOWRT +#define THREAD_PRIORITY_IDLE THREAD_BASE_PRIORITY_IDLE + // // Debug APIs // @@ -479,6 +537,7 @@ typedef struct _MEMORYSTATUS { #define LOAD_DLL_DEBUG_EVENT 6 #define UNLOAD_DLL_DEBUG_EVENT 7 #define OUTPUT_DEBUG_STRING_EVENT 8 +#define RIP_EVENT 9 typedef struct _EXCEPTION_DEBUG_INFO { EXCEPTION_RECORD ExceptionRecord; @@ -487,6 +546,7 @@ typedef struct _EXCEPTION_DEBUG_INFO { typedef struct _CREATE_THREAD_DEBUG_INFO { HANDLE hThread; + LPVOID lpThreadLocalBase; LPTHREAD_START_ROUTINE lpStartAddress; } CREATE_THREAD_DEBUG_INFO, *LPCREATE_THREAD_DEBUG_INFO; @@ -497,7 +557,10 @@ typedef struct _CREATE_PROCESS_DEBUG_INF LPVOID lpBaseOfImage; DWORD dwDebugInfoFileOffset; DWORD nDebugInfoSize; + LPVOID lpThreadLocalBase; LPTHREAD_START_ROUTINE lpStartAddress; + LPVOID lpImageName; + WORD fUnicode; } CREATE_PROCESS_DEBUG_INFO, *LPCREATE_PROCESS_DEBUG_INFO; typedef struct _EXIT_THREAD_DEBUG_INFO { @@ -513,6 +576,8 @@ typedef struct _LOAD_DLL_DEBUG_INFO { LPVOID lpBaseOfDll; DWORD dwDebugInfoFileOffset; DWORD nDebugInfoSize; + LPVOID lpImageName; + WORD fUnicode; } LOAD_DLL_DEBUG_INFO, *LPLOAD_DLL_DEBUG_INFO; typedef struct _UNLOAD_DLL_DEBUG_INFO { @@ -525,6 +590,12 @@ typedef struct _OUTPUT_DEBUG_STRING_INFO WORD nDebugStringLength; } OUTPUT_DEBUG_STRING_INFO, *LPOUTPUT_DEBUG_STRING_INFO; +typedef struct _RIP_INFO { + DWORD dwError; + DWORD dwType; +} RIP_INFO, *LPRIP_INFO; + + typedef struct _DEBUG_EVENT { DWORD dwDebugEventCode; DWORD dwProcessId; @@ -538,12 +609,13 @@ typedef struct _DEBUG_EVENT { LOAD_DLL_DEBUG_INFO LoadDll; UNLOAD_DLL_DEBUG_INFO UnloadDll; OUTPUT_DEBUG_STRING_INFO DebugString; + RIP_INFO RipInfo; } u; } DEBUG_EVENT, *LPDEBUG_EVENT; typedef PCONTEXT LPCONTEXT; typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD; -typedef EXCEPTION_POINTERS LPEXCEPTION_POINTERS; +typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS; #define DRIVE_REMOVABLE 2 #define DRIVE_FIXED 3 @@ -594,6 +666,8 @@ typedef EXCEPTION_POINTERS LPEXCEPTION_P #define CBR_19200 19200 #define CBR_38400 38400 #define CBR_56000 56000 +#define CBR_57600 57600 +#define CBR_115200 115200 #define CBR_128000 128000 #define CBR_256000 256000 @@ -725,7 +799,9 @@ typedef EXCEPTION_POINTERS LPEXCEPTION_P #define FS_CASE_IS_PRESERVED FILE_CASE_PRESERVED_NAMES #define FS_CASE_SENSITIVE FILE_CASE_SENSITIVE_SEARCH #define FS_UNICODE_STORED_ON_DISK FILE_UNICODE_ON_DISK +#define FS_PERSISTENT_ACLS FILE_PERSISTENT_ACLS +#define FILE_MAP_COPY SECTION_QUERY #define FILE_MAP_WRITE SECTION_MAP_WRITE #define FILE_MAP_READ SECTION_MAP_READ #define FILE_MAP_ALL_ACCESS SECTION_ALL_ACCESS @@ -747,205 +823,264 @@ typedef EXCEPTION_POINTERS LPEXCEPTION_P #define OF_EXIST 0x00004000 #define OF_REOPEN 0x00008000 +#define OFS_MAXPATHNAME 128 typedef struct _OFSTRUCT { BYTE cBytes; BYTE fFixedDisk; WORD nErrCode; WORD Reserved1; WORD Reserved2; - BYTE szPathName[120]; + CHAR szPathName[OFS_MAXPATHNAME]; } OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT; +// +// The MS-MIPS compiler supports intrinsic functions for interlocked +// increment, decrement, and exchange. +// + +#if defined(_M_MRX000) && !defined(RC_INVOKED) + +#define InterlockedIncrement _InterlockedIncrement +#define InterlockedDecrement _InterlockedDecrement +#define InterlockedExchange _InterlockedExchange + +#endif + LONG -APIENTRY +WINAPI InterlockedIncrement( LPLONG lpAddend ); LONG -APIENTRY +WINAPI InterlockedDecrement( LPLONG lpAddend ); -// MVDM related Stuff -#define MAXIMUM_VDM_COMMAND_LENGTH 128 -#define MAXIMUM_VDM_ENVIORNMENT 32*1024 -#define MAXIMUM_VDM_CURRENT_DIR 64 - -// VDMState defines -#define ASKING_FOR_FIRST_COMMAND 1 // Very First call. -#define ASKING_FOR_WOW_BINARY 2 // Caller is WOWVDM -#define ASKING_FOR_DOS_BINARY 4 // Caller is DOSVDM -#define ASKING_FOR_SECOND_TIME 8 // Caller is asking second time after - // allocating bigger buffers. -typedef struct _VDMINFO { - LPVOID CmdLine; - LPVOID Enviornment; - USHORT CmdSize; - USHORT CurDrive; - ULONG EnviornmentSize; - ULONG ErrorCode; - ULONG VDMState; - ULONG iTask; -} VDMINFO, *PVDMINFO; +LONG +WINAPI +InterlockedExchange( + LPLONG Target, + LONG Value + ); -DWORD -APIENTRY +#if defined(_M_MRX000) && !defined(RC_INVOKED) + +#pragma intrinsic(_InterlockedIncrement) +#pragma intrinsic(_InterlockedDecrement) +#pragma intrinsic(_InterlockedExchange) + +#endif + +BOOL +WINAPI FreeResource( - HANDLE hResData + HGLOBAL hResData ); -LPSTR -APIENTRY +LPVOID +WINAPI LockResource( - HANDLE hResData + HGLOBAL hResData ); #define UnlockResource(hResData) ((hResData), 0) #define MAXINTATOM 0xC000 -#define MAKEINTATOM(i) (LPSTR)((DWORD)((WORD)(i))) +#define MAKEINTATOM(i) (LPTSTR)((DWORD)((WORD)(i))) +#define INVALID_ATOM ((ATOM)0) int -APIENTRY +WINAPI WinMain( - HANDLE hInstance, - HANDLE hPrevInstance, + HINSTANCE hInstance, + HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd ); BOOL -APIENTRY +WINAPI FreeLibrary( - HANDLE hLibModule + HINSTANCE hLibModule ); FARPROC -APIENTRY +WINAPI GetProcAddress( - HANDLE hModule, - LPSTR lpProcName + HINSTANCE hModule, + LPCSTR lpProcName ); DWORD -APIENTRY +WINAPI GetVersion( VOID ); -HANDLE -APIENTRY +HGLOBAL +WINAPI GlobalAlloc( - DWORD dwFlags, + UINT uFlags, DWORD dwBytes ); -HANDLE -APIENTRY +HGLOBAL +WINAPI GlobalReAlloc( - HANDLE hMem, + HGLOBAL hMem, DWORD dwBytes, - DWORD dwFlags + UINT uFlags ); DWORD -APIENTRY +WINAPI GlobalSize( - HANDLE hMem + HGLOBAL hMem ); -DWORD -APIENTRY +UINT +WINAPI GlobalFlags( - HANDLE hMem + HGLOBAL hMem ); -LPSTR -APIENTRY +LPVOID +WINAPI GlobalLock( - HANDLE hMem + HGLOBAL hMem ); - -HANDLE -APIENTRY +//!!!MWH My version win31 = DWORD WINAPI GlobalHandle(UINT) +HGLOBAL +WINAPI GlobalHandle( - LPSTR pMem + LPCVOID pMem ); BOOL -APIENTRY +WINAPI GlobalUnlock( - HANDLE hMem + HGLOBAL hMem ); -LPVOID -APIENTRY +HGLOBAL +WINAPI GlobalFree( - HANDLE hMem + HGLOBAL hMem ); +UINT +WINAPI +GlobalCompact( + DWORD dwMinFree + ); VOID -APIENTRY +WINAPI +GlobalFix( + HGLOBAL hMem + ); + +VOID +WINAPI +GlobalUnfix( + HGLOBAL hMem + ); + +LPVOID +WINAPI +GlobalWire( + HGLOBAL hMem + ); + +BOOL +WINAPI +GlobalUnWire( + HGLOBAL hMem + ); + +VOID +WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ); -HANDLE -APIENTRY +HLOCAL +WINAPI LocalAlloc( - DWORD dwFlags, - DWORD dwBytes + UINT uFlags, + UINT uBytes ); -HANDLE -APIENTRY +HLOCAL +WINAPI LocalReAlloc( - HANDLE hMem, - DWORD dwBytes, - DWORD dwFlags + HLOCAL hMem, + UINT uBytes, + UINT uFlags ); -LPSTR -APIENTRY +LPVOID +WINAPI LocalLock( - HANDLE hMem + HLOCAL hMem ); -HANDLE -APIENTRY +HLOCAL +WINAPI LocalHandle( - LPSTR pMem + LPCVOID pMem ); BOOL -APIENTRY +WINAPI LocalUnlock( - HANDLE hMem + HLOCAL hMem ); -DWORD -APIENTRY +UINT +WINAPI LocalSize( - HANDLE hMem + HLOCAL hMem ); -DWORD +UINT +WINAPI LocalFlags( - HANDLE hMem + HLOCAL hMem ); -HANDLE -APIENTRY +HLOCAL +WINAPI LocalFree( - HANDLE hMem + HLOCAL hMem + ); + +UINT +WINAPI +LocalShrink( + HLOCAL hMem, + UINT cbNewSize + ); + +UINT +WINAPI +LocalCompact( + UINT uMinFree + ); + +BOOL +WINAPI +FlushInstructionCache( + HANDLE hProcess, + LPCVOID lpBaseAddress, + DWORD dwSize ); LPVOID -APIENTRY +WINAPI VirtualAlloc( LPVOID lpAddress, DWORD dwSize, @@ -954,7 +1089,7 @@ VirtualAlloc( ); BOOL -APIENTRY +WINAPI VirtualFree( LPVOID lpAddress, DWORD dwSize, @@ -962,7 +1097,7 @@ VirtualFree( ); BOOL -APIENTRY +WINAPI VirtualProtect( LPVOID lpAddress, DWORD dwSize, @@ -971,15 +1106,34 @@ VirtualProtect( ); DWORD -APIENTRY +WINAPI VirtualQuery( + LPCVOID lpAddress, + PMEMORY_BASIC_INFORMATION lpBuffer, + DWORD dwLength + ); + +BOOL +WINAPI +VirtualProtectEx( + HANDLE hProcess, LPVOID lpAddress, + DWORD dwSize, + DWORD flNewProtect, + PDWORD lpflOldProtect + ); + +DWORD +WINAPI +VirtualQueryEx( + HANDLE hProcess, + LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength ); HANDLE -APIENTRY +WINAPI HeapCreate( DWORD flOptions, DWORD dwInitialSize, @@ -987,35 +1141,60 @@ HeapCreate( ); BOOL -APIENTRY +WINAPI HeapDestroy( HANDLE hHeap ); -LPSTR -APIENTRY +LPVOID +WINAPI HeapAlloc( HANDLE hHeap, + DWORD dwFlags, + DWORD dwBytes + ); + +LPVOID +WINAPI +HeapReAlloc( + HANDLE hHeap, + DWORD dwFlags, + LPVOID lpMem, DWORD dwBytes ); BOOL -APIENTRY +WINAPI HeapFree( HANDLE hHeap, - LPSTR lpMem + DWORD dwFlags, + LPVOID lpMem ); DWORD -APIENTRY +WINAPI HeapSize( HANDLE hHeap, - LPSTR lpMem + DWORD dwFlags, + LPCVOID lpMem ); +HANDLE +WINAPI +GetProcessHeap( VOID ); + +BOOL +WINAPI +GetProcessTimes( + HANDLE hProcess, + LPFILETIME lpCreationTime, + LPFILETIME lpExitTime, + LPFILETIME lpKernelTime, + LPFILETIME lpUserTime + ); HANDLE -APIENTRY +WINAPI OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, @@ -1023,32 +1202,32 @@ OpenProcess( ); HANDLE -APIENTRY +WINAPI GetCurrentProcess( VOID ); DWORD -APIENTRY +WINAPI GetCurrentProcessId( VOID ); VOID -APIENTRY +WINAPI ExitProcess( - DWORD dwExitCode + UINT uExitCode ); BOOL -APIENTRY +WINAPI TerminateProcess( HANDLE hProcess, - DWORD dwExitCode + UINT uExitCode ); BOOL -APIENTRY +WINAPI GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode @@ -1056,34 +1235,45 @@ GetExitCodeProcess( VOID -APIENTRY +WINAPI FatalExit( - DWORD dwExitCode + int ExitCode ); LPVOID -APIENTRY +WINAPI GetEnvironmentStrings( VOID ); VOID -APIENTRY +WINAPI RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, - LPDWORD lpArguments + CONST DWORD *lpArguments ); -EXCEPTION_DISPOSITION -APIENTRY +LONG +WINAPI UnhandledExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo ); +typedef LONG (WINAPI *PTOP_LEVEL_EXCEPTION_FILTER)( + struct _EXCEPTION_POINTERS *ExceptionInfo + ); +typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER; + +LPTOP_LEVEL_EXCEPTION_FILTER +WINAPI +SetUnhandledExceptionFilter( + LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter + ); + HANDLE -APIENTRY +WINAPI CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, @@ -1094,52 +1284,74 @@ CreateThread( ); HANDLE -APIENTRY +WINAPI +CreateRemoteThread( + HANDLE hProcess, + LPSECURITY_ATTRIBUTES lpThreadAttributes, + DWORD dwStackSize, + LPTHREAD_START_ROUTINE lpStartAddress, + LPVOID lpParameter, + DWORD dwCreationFlags, + LPDWORD lpThreadId + ); + +HANDLE +WINAPI GetCurrentThread( VOID ); DWORD -APIENTRY +WINAPI GetCurrentThreadId( VOID ); BOOL -APIENTRY +WINAPI SetThreadPriority( HANDLE hThread, int nPriority ); int -APIENTRY +WINAPI GetThreadPriority( HANDLE hThread ); +BOOL +WINAPI +GetThreadTimes( + HANDLE hThread, + LPFILETIME lpCreationTime, + LPFILETIME lpExitTime, + LPFILETIME lpKernelTime, + LPFILETIME lpUserTime + ); + VOID -APIENTRY +WINAPI ExitThread( DWORD dwExitCode ); BOOL -APIENTRY +WINAPI TerminateThread( HANDLE hThread, DWORD dwExitCode ); BOOL -APIENTRY +WINAPI GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode ); BOOL -APIENTRY +WINAPI GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, @@ -1147,19 +1359,34 @@ GetThreadSelectorEntry( ); DWORD -APIENTRY +WINAPI GetLastError( VOID ); VOID -APIENTRY +WINAPI SetLastError( DWORD dwErrCode ); + +// +// SetLastErrorEx() types. +// +#define SLE_ERROR 0x00000001 +#define SLE_MINORERROR 0x00000002 +#define SLE_WARNING 0x00000003 + +VOID +WINAPI +SetLastErrorEx( + DWORD dwErrCode, + DWORD dwType + ); + BOOL -APIENTRY +WINAPI GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, @@ -1167,25 +1394,35 @@ GetOverlappedResult( BOOL bWait ); -BOOL -APIENTRY +#define SEM_FAILCRITICALERRORS 0x0001 +#define SEM_NOGPFAULTERRORBOX 0x0002 +#define SEM_NOOPENFILEERRORBOX 0x8000 + +VOID +WINAPI +SetDebugErrorLevel( + DWORD dwLevel + ); + +UINT +WINAPI SetErrorMode( - BOOL bMode + UINT uMode ); BOOL -APIENTRY +WINAPI ReadProcessMemory( HANDLE hProcess, - LPVOID lpBaseAddress, + LPCVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead ); BOOL -APIENTRY +WINAPI WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, @@ -1195,46 +1432,46 @@ WriteProcessMemory( ); BOOL -APIENTRY +WINAPI GetThreadContext( HANDLE hThread, LPCONTEXT lpContext ); BOOL -APIENTRY +WINAPI SetThreadContext( HANDLE hThread, - LPCONTEXT lpContext + CONST CONTEXT *lpContext ); DWORD -APIENTRY +WINAPI SuspendThread( HANDLE hThread ); DWORD -APIENTRY +WINAPI ResumeThread( - IN HANDLE hThread + HANDLE hThread ); VOID -APIENTRY +WINAPI DebugBreak( VOID ); BOOL -APIENTRY +WINAPI WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds ); BOOL -APIENTRY +WINAPI ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, @@ -1242,55 +1479,55 @@ ContinueDebugEvent( ); BOOL -APIENTRY +WINAPI DebugActiveProcess( DWORD dwProcessId ); VOID -APIENTRY +WINAPI InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID -APIENTRY +WINAPI EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID -APIENTRY +WINAPI LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID -APIENTRY +WINAPI DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); BOOL -APIENTRY +WINAPI SetEvent( HANDLE hEvent ); BOOL -APIENTRY +WINAPI ResetEvent( HANDLE hEvent ); BOOL -APIENTRY +WINAPI PulseEvent( HANDLE hEvent ); BOOL -APIENTRY +WINAPI ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, @@ -1298,133 +1535,180 @@ ReleaseSemaphore( ); BOOL -APIENTRY +WINAPI ReleaseMutex( HANDLE hMutex ); DWORD -APIENTRY +WINAPI WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds ); DWORD -APIENTRY +WINAPI WaitForMultipleObjects( DWORD nCount, - LPHANDLE lpHandles, + CONST HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds ); VOID -APIENTRY +WINAPI Sleep( DWORD dwMilliseconds ); -HANDLE -APIENTRY +HGLOBAL +WINAPI LoadResource( - HANDLE hModule, - HANDLE hResInfo + HINSTANCE hModule, + HRSRC hResInfo ); DWORD -APIENTRY +WINAPI SizeofResource( - HANDLE hModule, - HANDLE hResInfo + HINSTANCE hModule, + HRSRC hResInfo ); + ATOM -APIENTRY +WINAPI GlobalDeleteAtom( ATOM nAtom ); BOOL -APIENTRY +WINAPI InitAtomTable( DWORD nSize ); ATOM -APIENTRY +WINAPI DeleteAtom( ATOM nAtom ); -DWORD -APIENTRY +UINT +WINAPI SetHandleCount( - DWORD dwNumber + UINT uNumber ); DWORD -APIENTRY +WINAPI GetLogicalDrives( VOID ); BOOL -APIENTRY +WINAPI LockFile( HANDLE hFile, - DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, - DWORD nNumberOfBytesToLock + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh ); BOOL -APIENTRY +WINAPI UnlockFile( HANDLE hFile, - DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, - DWORD nNumberOfBytesToUnlock + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh + ); + +BOOL +WINAPI +LockFileEx( + HANDLE hFile, + DWORD dwFlags, + DWORD dwReserved, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh, + LPOVERLAPPED lpOverlapped + ); + +#define LOCKFILE_FAIL_IMMEDIATELY 0x00000001 +#define LOCKFILE_EXCLUSIVE_LOCK 0x00000002 + +BOOL +WINAPI +UnlockFileEx( + HANDLE hFile, + DWORD dwReserved, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh, + LPOVERLAPPED lpOverlapped + ); + +typedef struct _BY_HANDLE_FILE_INFORMATION { + DWORD dwFileAttributes; + FILETIME ftCreationTime; + FILETIME ftLastAccessTime; + FILETIME ftLastWriteTime; + DWORD dwVolumeSerialNumber; + DWORD nFileSizeHigh; + DWORD nFileSizeLow; + DWORD nNumberOfLinks; + DWORD nFileIndexHigh; + DWORD nFileIndexLow; +} BY_HANDLE_FILE_INFORMATION, *PBY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION; + +BOOL +WINAPI +GetFileInformationByHandle( + HANDLE hFile, + LPBY_HANDLE_FILE_INFORMATION lpFileInformation ); DWORD -APIENTRY +WINAPI GetFileType( HANDLE hFile ); DWORD -APIENTRY +WINAPI GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh ); HANDLE -APIENTRY +WINAPI GetStdHandle( DWORD nStdHandle ); BOOL -APIENTRY +WINAPI SetStdHandle( DWORD nStdHandle, HANDLE hHandle ); BOOL -APIENTRY +WINAPI WriteFile( HANDLE hFile, - LPVOID lpBuffer, + LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped ); BOOL -APIENTRY +WINAPI ReadFile( HANDLE hFile, LPVOID lpBuffer, @@ -1434,19 +1718,32 @@ ReadFile( ); BOOL -APIENTRY +WINAPI FlushFileBuffers( HANDLE hFile ); BOOL -APIENTRY +WINAPI +DeviceIoControl( + HANDLE hDevice, + DWORD dwIoControlCode, + LPVOID lpInBuffer, + DWORD nInBufferSize, + LPVOID lpOutBuffer, + DWORD nOutBufferSize, + LPDWORD lpBytesReturned, + LPOVERLAPPED lpOverlapped + ); + +BOOL +WINAPI SetEndOfFile( HANDLE hFile ); DWORD -APIENTRY +WINAPI SetFilePointer( HANDLE hFile, LONG lDistanceToMove, @@ -1455,13 +1752,13 @@ SetFilePointer( ); BOOL -APIENTRY +WINAPI FindClose( HANDLE hFindFile ); BOOL -APIENTRY +WINAPI GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, @@ -1470,22 +1767,22 @@ GetFileTime( ); BOOL -APIENTRY +WINAPI SetFileTime( HANDLE hFile, - LPFILETIME lpCreationTime, - LPFILETIME lpLastAccessTime, - LPFILETIME lpLastWriteTime + CONST FILETIME *lpCreationTime, + CONST FILETIME *lpLastAccessTime, + CONST FILETIME *lpLastWriteTime ); BOOL -APIENTRY +WINAPI CloseHandle( HANDLE hObject ); BOOL -APIENTRY +WINAPI DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, @@ -1496,35 +1793,45 @@ DuplicateHandle( DWORD dwOptions ); +#define HINSTANCE_ERROR 32 + DWORD -APIENTRY +WINAPI LoadModule( - LPSTR lpModuleName, + LPCSTR lpModuleName, LPVOID lpParameterBlock ); -DWORD -APIENTRY +UINT +WINAPI WinExec( - LPSTR lpCmdLine, - WORD nCmdShow + LPCSTR lpCmdLine, + UINT uCmdShow ); BOOL -APIENTRY +WINAPI BuildCommDCB( LPSTR lpDef, LPDCB lpDCB ); BOOL -APIENTRY +WINAPI +BuildCommDCBAndTimeouts( + LPSTR lpDef, + LPDCB lpDCB, + LPCOMMTIMEOUTS lpCommTimeouts + ); + +BOOL +WINAPI ClearCommBreak( HANDLE hFile ); BOOL -APIENTRY +WINAPI ClearCommError( HANDLE hFile, LPDWORD lpErrors, @@ -1532,7 +1839,7 @@ ClearCommError( ); BOOL -APIENTRY +WINAPI SetupComm( HANDLE hFile, DWORD dwInQueue, @@ -1540,196 +1847,251 @@ SetupComm( ); BOOL -APIENTRY -EnableCommNotification( - HANDLE hFile, - HANDLE hWnd, - DWORD dwInTrigger, - DWORD dwOutTrigger - ); - -BOOL -APIENTRY +WINAPI EscapeCommFunction( HANDLE hFile, DWORD dwFunc ); BOOL -APIENTRY -ExtendedProviderFunction( - HANDLE hFile, - WORD wCatagory, - WORD wFunction, - LPVOID lpParam, - LPVOID lpData, - DWORD dwParamLength, - LPDWORD lpDataLength - ); - -BOOL -APIENTRY -GetCommConfig( +WINAPI +GetCommMask( HANDLE hFile, - LPVOID lpCOMMCONFIG, - DWORD dwSize + LPDWORD lpEvtMask ); BOOL -APIENTRY -GetCommMask( +WINAPI +GetCommProperties( HANDLE hFile, - LPDWORD lpEvtMask + LPCOMMPROP lpCommProp ); BOOL -APIENTRY +WINAPI GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat ); BOOL -APIENTRY +WINAPI GetCommState( HANDLE hFile, LPDCB lpDCB ); BOOL -APIENTRY +WINAPI GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); BOOL -APIENTRY +WINAPI PurgeComm( HANDLE hFile, DWORD dwFlags ); BOOL -APIENTRY +WINAPI SetCommBreak( HANDLE hFile ); BOOL -APIENTRY -SetCommConfig( - HANDLE hFile, - LPVOID lpCOMMCONFIG, - DWORD dwSize - ); - -BOOL -APIENTRY +WINAPI SetCommMask( HANDLE hFile, DWORD dwEvtMask ); BOOL -APIENTRY +WINAPI SetCommState( HANDLE hFile, LPDCB lpDCB ); BOOL -APIENTRY +WINAPI SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); BOOL -APIENTRY +WINAPI TransmitCommChar( HANDLE hFile, char cChar ); BOOL -APIENTRY +WINAPI WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, - HANDLE hEvent + LPOVERLAPPED lpOverlapped + ); + + +DWORD +WINAPI +SetTapePosition( + HANDLE hDevice, + DWORD dwPositionMethod, + DWORD dwPartition, + DWORD dwOffsetLow, + DWORD dwOffsetHigh, + BOOL bImmediate + ); + +DWORD +WINAPI +GetTapePosition( + HANDLE hDevice, + DWORD dwPositionType, + LPDWORD lpdwPartition, + LPDWORD lpdwOffsetLow, + LPDWORD lpdwOffsetHigh + ); + +DWORD +WINAPI +PrepareTape( + HANDLE hDevice, + DWORD dwOperation, + BOOL bImmediate + ); + +DWORD +WINAPI +EraseTape( + HANDLE hDevice, + DWORD dwEraseType, + BOOL bImmediate + ); + +DWORD +WINAPI +CreateTapePartition( + HANDLE hDevice, + DWORD dwPartitionMethod, + DWORD dwCount, + DWORD dwSize ); +DWORD +WINAPI +WriteTapemark( + HANDLE hDevice, + DWORD dwTapemarkType, + DWORD dwTapemarkCount, + BOOL bImmediate + ); + +DWORD +WINAPI +GetTapeStatus( + HANDLE hDevice + ); + +DWORD +WINAPI +GetTapeParameters( + HANDLE hDevice, + DWORD dwOperation, + LPDWORD lpdwSize, + LPVOID lpTapeInformation + ); + +#define GET_TAPE_MEDIA_INFORMATION 0 +#define GET_TAPE_DRIVE_INFORMATION 1 + +DWORD +WINAPI +SetTapeParameters( + HANDLE hDevice, + DWORD dwOperation, + LPVOID lpTapeInformation + ); + +#define SET_TAPE_MEDIA_INFORMATION 0 +#define SET_TAPE_DRIVE_INFORMATION 1 + BOOL -APIENTRY +WINAPI Beep( DWORD dwFreq, DWORD dwDuration ); VOID -APIENTRY +WINAPI OpenSound( VOID ); VOID -APIENTRY +WINAPI CloseSound( VOID ); VOID -APIENTRY +WINAPI StartSound( VOID ); VOID -APIENTRY +WINAPI StopSound( VOID ); DWORD -APIENTRY +WINAPI WaitSoundState( DWORD nState ); DWORD -APIENTRY +WINAPI SyncAllVoices( VOID ); DWORD -APIENTRY +WINAPI CountVoiceNotes( DWORD nVoice ); LPDWORD -APIENTRY +WINAPI GetThresholdEvent( VOID ); DWORD -APIENTRY +WINAPI GetThresholdStatus( VOID ); DWORD -APIENTRY +WINAPI SetSoundNoise( DWORD nSource, DWORD nDuration ); DWORD -APIENTRY +WINAPI SetVoiceAccent( DWORD nVoice, DWORD nTempo, @@ -1739,7 +2101,7 @@ SetVoiceAccent( ); DWORD -APIENTRY +WINAPI SetVoiceEnvelope( DWORD nVoice, DWORD nShape, @@ -1747,7 +2109,7 @@ SetVoiceEnvelope( ); DWORD -APIENTRY +WINAPI SetVoiceNote( DWORD nVoice, DWORD nValue, @@ -1756,29 +2118,29 @@ SetVoiceNote( ); DWORD -APIENTRY +WINAPI SetVoiceQueueSize( DWORD nVoice, DWORD nBytes ); DWORD -APIENTRY +WINAPI SetVoiceSound( DWORD nVoice, - LONG lFrequency, + DWORD Frequency, DWORD nDuration ); DWORD -APIENTRY +WINAPI SetVoiceThreshold( DWORD nVoice, DWORD nNotes ); int -APIENTRY +WINAPI MulDiv( int nNumber, int nNumerator, @@ -1786,59 +2148,107 @@ MulDiv( ); VOID -APIENTRY +WINAPI GetSystemTime( LPSYSTEMTIME lpSystemTime ); BOOL -APIENTRY +WINAPI SetSystemTime( + CONST SYSTEMTIME *lpSystemTime + ); + +VOID +WINAPI +GetLocalTime( LPSYSTEMTIME lpSystemTime ); +BOOL +WINAPI +SetLocalTime( + CONST SYSTEMTIME *lpSystemTime + ); + VOID -APIENTRY +WINAPI GetSystemInfo( LPSYSTEM_INFO lpSystemInfo ); +typedef struct _TIME_ZONE_INFORMATION { + LONG Bias; + WCHAR StandardName[ 32 ]; + SYSTEMTIME StandardDate; + LONG StandardBias; + WCHAR DaylightName[ 32 ]; + SYSTEMTIME DaylightDate; + LONG DaylightBias; +} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION; + + +DWORD +WINAPI +GetTimeZoneInformation( + LPTIME_ZONE_INFORMATION lpTimeZoneInformation + ); + +BOOL +WINAPI +SetTimeZoneInformation( + CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation + ); // // Routines to convert back and forth between system time and file time // BOOL -APIENTRY +WINAPI SystemTimeToFileTime( - LPSYSTEMTIME lpSystemTime, + CONST SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime ); BOOL -APIENTRY +WINAPI +FileTimeToLocalFileTime( + CONST FILETIME *lpFileTime, + LPFILETIME lpLocalFileTime + ); + +BOOL +WINAPI +LocalFileTimeToFileTime( + CONST FILETIME *lpLocalFileTime, + LPFILETIME lpFileTime + ); + +BOOL +WINAPI FileTimeToSystemTime( - LPFILETIME lpFileTime, + CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime ); LONG -APIENTRY +WINAPI CompareFileTime( - LPFILETIME lpFileTime1, - LPFILETIME lpFileTime2 + CONST FILETIME *lpFileTime1, + CONST FILETIME *lpFileTime2 ); BOOL -APIENTRY +WINAPI FileTimeToDosDateTime( - LPFILETIME lpFileTime, + CONST FILETIME *lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime ); BOOL -APIENTRY +WINAPI DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, @@ -1846,33 +2256,50 @@ DosDateTimeToFileTime( ); DWORD -APIENTRY +WINAPI GetTickCount( VOID ); DWORD -APIENTRY -FormatMessage( +WINAPI +FormatMessageA( DWORD dwFlags, - LPVOID lpSource, + LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, - LPVOID lpArguments + va_list *Arguments ); +DWORD +WINAPI +FormatMessageW( + DWORD dwFlags, + LPCVOID lpSource, + DWORD dwMessageId, + DWORD dwLanguageId, + LPWSTR lpBuffer, + DWORD nSize, + va_list *Arguments + ); +#ifdef UNICODE +#define FormatMessage FormatMessageW +#else +#define FormatMessage FormatMessageA +#endif // !UNICODE #define FORMAT_MESSAGE_ALLOCATE_BUFFER 0x00000100 #define FORMAT_MESSAGE_IGNORE_INSERTS 0x00000200 #define FORMAT_MESSAGE_FROM_STRING 0x00000400 #define FORMAT_MESSAGE_FROM_HMODULE 0x00000800 #define FORMAT_MESSAGE_FROM_SYSTEM 0x00001000 +#define FORMAT_MESSAGE_ARGUMENT_ARRAY 0x00002000 #define FORMAT_MESSAGE_MAX_WIDTH_MASK 0x000000FF BOOL -APIENTRY +WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, @@ -1881,20 +2308,20 @@ CreatePipe( ); BOOL -APIENTRY +WINAPI ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped ); BOOL -APIENTRY +WINAPI DisconnectNamedPipe( HANDLE hNamedPipe ); BOOL -APIENTRY +WINAPI SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, @@ -1903,7 +2330,7 @@ SetNamedPipeHandleState( ); BOOL -APIENTRY +WINAPI GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, @@ -1913,7 +2340,7 @@ GetNamedPipeInfo( ); BOOL -APIENTRY +WINAPI PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, @@ -1924,7 +2351,7 @@ PeekNamedPipe( ); BOOL -APIENTRY +WINAPI TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, @@ -1936,49 +2363,46 @@ TransactNamedPipe( ); HANDLE -APIENTRY +WINAPI CreateMailslotA( - IN LPSTR lpName, - IN DWORD nMaxMessageSize, - IN DWORD nMailslotSize, - IN DWORD lReadTimeout, - IN LPSECURITY_ATTRIBUTES lpSecurityAttributes OPTIONAL + LPCSTR lpName, + DWORD nMaxMessageSize, + DWORD lReadTimeout, + LPSECURITY_ATTRIBUTES lpSecurityAttributes ); HANDLE -APIENTRY +WINAPI CreateMailslotW( - IN LPWSTR lpName, - IN DWORD nMaxMessageSize, - IN DWORD nMailslotSize, - IN DWORD lReadTimeout, - IN LPSECURITY_ATTRIBUTES lpSecurityAttributes OPTIONAL + LPCWSTR lpName, + DWORD nMaxMessageSize, + DWORD lReadTimeout, + LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE -#define CreateMailslot CreateMailslotW +#define CreateMailslot CreateMailslotW #else -#define CreateMailslot CreateMailslotA +#define CreateMailslot CreateMailslotA #endif // !UNICODE BOOL -APIENTRY +WINAPI GetMailslotInfo( - IN HANDLE hMailslot, - OUT LPDWORD lpMaxMessageSize OPTIONAL, - OUT LPDWORD lpMailslotSize OPTIONAL, - OUT LPDWORD lpNextSize OPTIONAL, - OUT LPDWORD lpMessageCount OPTIONAL, - OUT LPDWORD lpReadTimeout OPTIONAL + HANDLE hMailslot, + LPDWORD lpMaxMessageSize, + LPDWORD lpNextSize, + LPDWORD lpMessageCount, + LPDWORD lpReadTimeout ); BOOL -APIENTRY +WINAPI SetMailslotInfo( - IN HANDLE hMailslot, - IN DWORD lReadTimeout + HANDLE hMailslot, + DWORD lReadTimeout ); LPVOID -APIENTRY +WINAPI MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, @@ -1988,14 +2412,14 @@ MapViewOfFile( ); BOOL -APIENTRY +WINAPI FlushViewOfFile( - LPVOID lpBaseAddress, + LPCVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush ); BOOL -APIENTRY +WINAPI UnmapViewOfFile( LPVOID lpBaseAddress ); @@ -2005,133 +2429,317 @@ UnmapViewOfFile( // int -APIENTRY -lstrcmp( - LPSTR lpString1, - LPSTR lpString2 +WINAPI +lstrcmpA( + LPCSTR lpString1, + LPCSTR lpString2 ); +int +WINAPI +lstrcmpW( + LPCWSTR lpString1, + LPCWSTR lpString2 + ); +#ifdef UNICODE +#define lstrcmp lstrcmpW +#else +#define lstrcmp lstrcmpA +#endif // !UNICODE int -APIENTRY -lstrcmpi( - LPSTR lpString1, - LPSTR lpString2 +WINAPI +lstrcmpiA( + LPCSTR lpString1, + LPCSTR lpString2 + ); +int +WINAPI +lstrcmpiW( + LPCWSTR lpString1, + LPCWSTR lpString2 ); +#ifdef UNICODE +#define lstrcmpi lstrcmpiW +#else +#define lstrcmpi lstrcmpiA +#endif // !UNICODE LPSTR -APIENTRY -lstrcpy( +WINAPI +lstrcpyA( LPSTR lpString1, - LPSTR lpString2 + LPCSTR lpString2 ); +LPWSTR +WINAPI +lstrcpyW( + LPWSTR lpString1, + LPCWSTR lpString2 + ); +#ifdef UNICODE +#define lstrcpy lstrcpyW +#else +#define lstrcpy lstrcpyA +#endif // !UNICODE LPSTR -APIENTRY -lstrcat( +WINAPI +lstrcatA( LPSTR lpString1, - LPSTR lpString2 + LPCSTR lpString2 ); +LPWSTR +WINAPI +lstrcatW( + LPWSTR lpString1, + LPCWSTR lpString2 + ); +#ifdef UNICODE +#define lstrcat lstrcatW +#else +#define lstrcat lstrcatA +#endif // !UNICODE int -APIENTRY -lstrlen( - LPSTR lpString +WINAPI +lstrlenA( + LPCSTR lpString ); - int -APIENTRY -OpenFile( - LPSTR lpFileName, - LPOFSTRUCT lpReOpenBuff, - WORD wStyle +WINAPI +lstrlenW( + LPCWSTR lpString ); +#ifdef UNICODE +#define lstrlen lstrlenW +#else +#define lstrlen lstrlenA +#endif // !UNICODE -int -APIENTRY -OpenSystemFile( - LPSTR lpFileName, +HFILE +WINAPI +OpenFile( + LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, - WORD wStyle + UINT uStyle ); -int -APIENTRY +HFILE +WINAPI _lopen( - LPSTR lpPathName, + LPCSTR lpPathName, int iReadWrite ); -int -APIENTRY +HFILE +WINAPI _lcreat( - LPSTR lpPathName, - WORD iAttribute + LPCSTR lpPathName, + int iAttribute ); -DWORD -APIENTRY +UINT +WINAPI _lread( - int hFile, - LPSTR lpBuffer, - int nBytes + HFILE hFile, + LPVOID lpBuffer, + UINT uBytes ); -DWORD -APIENTRY +UINT +WINAPI _lwrite( - int hFile, - LPSTR lpBuffer, - int nBytes + HFILE hFile, + LPCSTR lpBuffer, + UINT uBytes ); -int -APIENTRY +long +WINAPI +_hread( + HFILE hFile, + LPVOID lpBuffer, + long lBytes + ); + +long +WINAPI +_hwrite( + HFILE hFile, + LPCSTR lpBuffer, + long lBytes + ); + +HFILE +WINAPI _lclose( - int hFile + HFILE hFile ); -int -APIENTRY +LONG +WINAPI _llseek( - int hFile, - int lOffset, + HFILE hFile, + LONG lOffset, int iOrigin ); DWORD -APIENTRY +WINAPI TlsAlloc( VOID ); +#define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF + LPVOID -APIENTRY +WINAPI TlsGetValue( DWORD dwTlsIndex ); BOOL -APIENTRY +WINAPI TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue ); BOOL -APIENTRY +WINAPI TlsFree( DWORD dwTlsIndex ); +typedef +VOID +(WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)( + DWORD dwErrorCode, + DWORD dwNumberOfBytesTransfered, + LPOVERLAPPED lpOverlapped + ); + +DWORD +WINAPI +SleepEx( + DWORD dwMilliseconds, + BOOL bAlertable + ); + +DWORD +WINAPI +WaitForSingleObjectEx( + HANDLE hHandle, + DWORD dwMilliseconds, + BOOL bAlertable + ); + +DWORD +WINAPI +WaitForMultipleObjectsEx( + DWORD nCount, + CONST HANDLE *lpHandles, + BOOL bWaitAll, + DWORD dwMilliseconds, + BOOL bAlertable + ); + +BOOL +WINAPI +ReadFileEx( + HANDLE hFile, + LPVOID lpBuffer, + DWORD nNumberOfBytesToRead, + LPOVERLAPPED lpOverlapped, + LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine + ); + +BOOL +WINAPI +WriteFileEx( + HANDLE hFile, + LPCVOID lpBuffer, + DWORD nNumberOfBytesToWrite, + LPOVERLAPPED lpOverlapped, + LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine + ); + +BOOL +WINAPI +BackupRead( + HANDLE hFile, + LPBYTE lpBuffer, + DWORD nNumberOfBytesToRead, + LPDWORD lpNumberOfBytesRead, + BOOL bAbort, + BOOL bProcessSecurity, + LPVOID *lpContext + ); + +BOOL +WINAPI +BackupSeek( + HANDLE hFile, + DWORD dwLowBytesToSeek, + DWORD dwHighBytesToSeek, + LPDWORD lpdwLowByteSeeked, + LPDWORD lpdwHighByteSeeked, + LPVOID *lpContext + ); + +BOOL +WINAPI +BackupWrite( + HANDLE hFile, + LPBYTE lpBuffer, + DWORD nNumberOfBytesToWrite, + LPDWORD lpNumberOfBytesWritten, + BOOL bAbort, + BOOL bProcessSecurity, + LPVOID *lpContext + ); + +// +// Stream id structure +// +typedef struct _WIN32_STREAM_ID { + DWORD dwStreamId ; + DWORD dwStreamAttributes ; + LARGE_INTEGER Size ; + DWORD dwStreamNameSize ; + WCHAR cStreamName[ ANYSIZE_ARRAY ] ; +} WIN32_STREAM_ID, *LPWIN32_STREAM_ID ; + +// +// Stream Ids +// + +#define BACKUP_DATA 0x00000001 +#define BACKUP_EA_DATA 0x00000002 +#define BACKUP_SECURITY_DATA 0x00000003 +#define BACKUP_ALTERNATE_DATA 0x00000004 +#define BACKUP_LINK 0x00000005 + +// +// Stream Attributes +// + +#define STREAM_MODIFIED_WHEN_READ 0x0001 +#define STREAM_CONTAINS_SECURITY 0x0002 + // // Dual Mode API below this line. Dual Mode Structures also included. // -#define STARTF_USESHOWWINDOW 1 -#define STARTF_USESIZE 2 -#define STARTF_USEPOSITION 4 -#define STARTF_USECOUNTCHARS 8 -#define STARTF_USEFILLATTRIBUTE 16 +#define STARTF_USESHOWWINDOW 0x00000001 +#define STARTF_USESIZE 0x00000002 +#define STARTF_USEPOSITION 0x00000004 +#define STARTF_USECOUNTCHARS 0x00000008 +#define STARTF_USEFILLATTRIBUTE 0x00000010 +#define STARTF_RUNFULLSCREEN 0x00000020 // ignored for non-x86 platforms +#define STARTF_FORCEONFEEDBACK 0x00000040 +#define STARTF_FORCEOFFFEEDBACK 0x00000080 +#define STARTF_USESTDHANDLES 0x00000100 typedef struct _STARTUPINFOA { DWORD cb; @@ -2149,6 +2757,9 @@ typedef struct _STARTUPINFOA { WORD wShowWindow; WORD cbReserved2; LPBYTE lpReserved2; + HANDLE hStdInput; + HANDLE hStdOutput; + HANDLE hStdError; } STARTUPINFOA, *LPSTARTUPINFOA; typedef struct _STARTUPINFOW { DWORD cb; @@ -2166,15 +2777,20 @@ typedef struct _STARTUPINFOW { WORD wShowWindow; WORD cbReserved2; LPBYTE lpReserved2; + HANDLE hStdInput; + HANDLE hStdOutput; + HANDLE hStdError; } STARTUPINFOW, *LPSTARTUPINFOW; #ifdef UNICODE -#define STARTUPINFO STARTUPINFOW -#define LPSTARTUPINFO LPSTARTUPINFOW +typedef STARTUPINFOW STARTUPINFO; +typedef LPSTARTUPINFOW LPSTARTUPINFO; #else -#define STARTUPINFO STARTUPINFOA -#define LPSTARTUPINFO LPSTARTUPINFOA +typedef STARTUPINFOA STARTUPINFO; +typedef LPSTARTUPINFOA LPSTARTUPINFO; #endif // UNICODE +#define SHUTDOWN_NORETRY 0x00000001 + typedef struct _WIN32_FIND_DATAA { DWORD dwFileAttributes; FILETIME ftCreationTime; @@ -2182,7 +2798,10 @@ typedef struct _WIN32_FIND_DATAA { FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; + DWORD dwReserved0; + DWORD dwReserved1; CHAR cFileName[ MAX_PATH ]; + CHAR cAlternateFileName[ 14 ]; } WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA; typedef struct _WIN32_FIND_DATAW { DWORD dwFileAttributes; @@ -2191,990 +2810,1235 @@ typedef struct _WIN32_FIND_DATAW { FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; + DWORD dwReserved0; + DWORD dwReserved1; WCHAR cFileName[ MAX_PATH ]; + WCHAR cAlternateFileName[ 14 ]; } WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW; #ifdef UNICODE -#define WIN32_FIND_DATA WIN32_FIND_DATAW -#define PWIN32_FIND_DATA PWIN32_FIND_DATAW -#define LPWIN32_FIND_DATA LPWIN32_FIND_DATAW -#else -#define WIN32_FIND_DATA WIN32_FIND_DATAA -#define PWIN32_FIND_DATA PWIN32_FIND_DATAA -#define LPWIN32_FIND_DATA LPWIN32_FIND_DATAA +typedef WIN32_FIND_DATAW WIN32_FIND_DATA; +typedef PWIN32_FIND_DATAW PWIN32_FIND_DATA; +typedef LPWIN32_FIND_DATAW LPWIN32_FIND_DATA; +#else +typedef WIN32_FIND_DATAA WIN32_FIND_DATA; +typedef PWIN32_FIND_DATAA PWIN32_FIND_DATA; +typedef LPWIN32_FIND_DATAA LPWIN32_FIND_DATA; #endif // UNICODE HANDLE -APIENTRY +WINAPI CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define CreateMutex CreateMutexW +#define CreateMutex CreateMutexW #else -#define CreateMutex CreateMutexA +#define CreateMutex CreateMutexA #endif // !UNICODE HANDLE -APIENTRY +WINAPI OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define OpenMutex OpenMutexW +#define OpenMutex OpenMutexW #else -#define OpenMutex OpenMutexA +#define OpenMutex OpenMutexA #endif // !UNICODE HANDLE -APIENTRY +WINAPI CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define CreateEvent CreateEventW +#define CreateEvent CreateEventW #else -#define CreateEvent CreateEventA +#define CreateEvent CreateEventA #endif // !UNICODE HANDLE -APIENTRY +WINAPI OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define OpenEvent OpenEventW +#define OpenEvent OpenEventW #else -#define OpenEvent OpenEventA +#define OpenEvent OpenEventA #endif // !UNICODE HANDLE -APIENTRY +WINAPI CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define CreateSemaphore CreateSemaphoreW +#define CreateSemaphore CreateSemaphoreW #else -#define CreateSemaphore CreateSemaphoreA +#define CreateSemaphore CreateSemaphoreA #endif // !UNICODE HANDLE -APIENTRY +WINAPI OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define OpenSemaphore OpenSemaphoreW +#define OpenSemaphore OpenSemaphoreW #else -#define OpenSemaphore OpenSemaphoreA +#define OpenSemaphore OpenSemaphoreA #endif // !UNICODE HANDLE -APIENTRY +WINAPI CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define CreateFileMapping CreateFileMappingW +#define CreateFileMapping CreateFileMappingW #else -#define CreateFileMapping CreateFileMappingA +#define CreateFileMapping CreateFileMappingA #endif // !UNICODE HANDLE -APIENTRY +WINAPI OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPSTR lpName + LPCSTR lpName ); HANDLE -APIENTRY +WINAPI OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, - LPWSTR lpName + LPCWSTR lpName ); #ifdef UNICODE -#define OpenFileMapping OpenFileMappingW +#define OpenFileMapping OpenFileMappingW #else -#define OpenFileMapping OpenFileMappingA +#define OpenFileMapping OpenFileMappingA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD -APIENTRY +WINAPI GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE -#define GetLogicalDriveStrings GetLogicalDriveStringsW +#define GetLogicalDriveStrings GetLogicalDriveStringsW #else -#define GetLogicalDriveStrings GetLogicalDriveStringsA +#define GetLogicalDriveStrings GetLogicalDriveStringsA #endif // !UNICODE -HANDLE -APIENTRY +HINSTANCE +WINAPI LoadLibraryA( - LPSTR lpLibFileName + LPCSTR lpLibFileName ); -HANDLE -APIENTRY +HINSTANCE +WINAPI LoadLibraryW( - LPWSTR lpLibFileName + LPCWSTR lpLibFileName + ); +#ifdef UNICODE +#define LoadLibrary LoadLibraryW +#else +#define LoadLibrary LoadLibraryA +#endif // !UNICODE + +HINSTANCE +WINAPI +LoadLibraryExA( + LPCSTR lpLibFileName, + HANDLE hFile, + DWORD dwFlags + ); +HINSTANCE +WINAPI +LoadLibraryExW( + LPCWSTR lpLibFileName, + HANDLE hFile, + DWORD dwFlags ); #ifdef UNICODE -#define LoadLibrary LoadLibraryW +#define LoadLibraryEx LoadLibraryExW #else -#define LoadLibrary LoadLibraryA +#define LoadLibraryEx LoadLibraryExA #endif // !UNICODE +#define DONT_RESOLVE_DLL_REFERENCES 0x00000001 + + DWORD -APIENTRY +WINAPI GetModuleFileNameA( - HANDLE hModule, + HINSTANCE hModule, LPSTR lpFilename, DWORD nSize ); DWORD -APIENTRY +WINAPI GetModuleFileNameW( - HANDLE hModule, + HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize ); #ifdef UNICODE -#define GetModuleFileName GetModuleFileNameW +#define GetModuleFileName GetModuleFileNameW #else -#define GetModuleFileName GetModuleFileNameA +#define GetModuleFileName GetModuleFileNameA #endif // !UNICODE -HANDLE -APIENTRY +HMODULE +WINAPI GetModuleHandleA( - LPSTR lpModuleName + LPCSTR lpModuleName ); -HANDLE -APIENTRY +HMODULE +WINAPI GetModuleHandleW( - LPWSTR lpModuleName + LPCWSTR lpModuleName ); #ifdef UNICODE -#define GetModuleHandle GetModuleHandleW +#define GetModuleHandle GetModuleHandleW #else -#define GetModuleHandle GetModuleHandleA +#define GetModuleHandle GetModuleHandleA #endif // !UNICODE BOOL -APIENTRY +WINAPI CreateProcessA( - LPSTR lpApplicationName, - LPSTR lpCommandLine, + LPCSTR lpApplicationName, + LPCSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, - LPSTR lpCurrentDirectory, + LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); BOOL -APIENTRY +WINAPI CreateProcessW( - LPWSTR lpApplicationName, - LPWSTR lpCommandLine, + LPCWSTR lpApplicationName, + LPCWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, - LPWSTR lpCurrentDirectory, + LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); #ifdef UNICODE -#define CreateProcess CreateProcessW +#define CreateProcess CreateProcessW #else -#define CreateProcess CreateProcessA +#define CreateProcess CreateProcessA #endif // !UNICODE +BOOL +WINAPI +SetProcessShutdownParameters( + DWORD dwLevel, + DWORD dwFlags + ); + +BOOL +WINAPI +GetProcessShutdownParameters( + LPDWORD lpdwLevel, + LPDWORD lpdwFlags + ); + VOID -APIENTRY +WINAPI FatalAppExitA( - WORD wAction, - LPSTR lpMessageText + UINT uAction, + LPCSTR lpMessageText ); VOID -APIENTRY +WINAPI FatalAppExitW( - WORD wAction, - LPWSTR lpMessageText + UINT uAction, + LPCWSTR lpMessageText ); #ifdef UNICODE -#define FatalAppExit FatalAppExitW +#define FatalAppExit FatalAppExitW #else -#define FatalAppExit FatalAppExitA +#define FatalAppExit FatalAppExitA #endif // !UNICODE VOID -APIENTRY +WINAPI GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo ); VOID -APIENTRY +WINAPI GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo ); #ifdef UNICODE -#define GetStartupInfo GetStartupInfoW +#define GetStartupInfo GetStartupInfoW #else -#define GetStartupInfo GetStartupInfoA +#define GetStartupInfo GetStartupInfoA #endif // !UNICODE LPSTR -APIENTRY +WINAPI GetCommandLineA( VOID ); LPWSTR -APIENTRY +WINAPI GetCommandLineW( VOID ); #ifdef UNICODE -#define GetCommandLine GetCommandLineW +#define GetCommandLine GetCommandLineW #else -#define GetCommandLine GetCommandLineA +#define GetCommandLine GetCommandLineA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetEnvironmentVariableA( - LPSTR lpName, + LPCSTR lpName, LPSTR lpBuffer, DWORD nSize ); DWORD -APIENTRY +WINAPI GetEnvironmentVariableW( - LPWSTR lpName, + LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize ); #ifdef UNICODE -#define GetEnvironmentVariable GetEnvironmentVariableW +#define GetEnvironmentVariable GetEnvironmentVariableW #else -#define GetEnvironmentVariable GetEnvironmentVariableA +#define GetEnvironmentVariable GetEnvironmentVariableA #endif // !UNICODE BOOL -APIENTRY +WINAPI SetEnvironmentVariableA( - LPSTR lpName, - LPSTR lpValue + LPCSTR lpName, + LPCSTR lpValue ); BOOL -APIENTRY +WINAPI SetEnvironmentVariableW( - LPWSTR lpName, - LPWSTR lpValue + LPCWSTR lpName, + LPCWSTR lpValue + ); +#ifdef UNICODE +#define SetEnvironmentVariable SetEnvironmentVariableW +#else +#define SetEnvironmentVariable SetEnvironmentVariableA +#endif // !UNICODE + +DWORD +WINAPI +ExpandEnvironmentStringsA( + LPCSTR lpSrc, + LPSTR lpDst, + DWORD nSize + ); +DWORD +WINAPI +ExpandEnvironmentStringsW( + LPCWSTR lpSrc, + LPWSTR lpDst, + DWORD nSize ); #ifdef UNICODE -#define SetEnvironmentVariable SetEnvironmentVariableW +#define ExpandEnvironmentStrings ExpandEnvironmentStringsW #else -#define SetEnvironmentVariable SetEnvironmentVariableA +#define ExpandEnvironmentStrings ExpandEnvironmentStringsA #endif // !UNICODE VOID -APIENTRY +WINAPI OutputDebugStringA( - LPSTR lpOutputString + LPCSTR lpOutputString ); VOID -APIENTRY +WINAPI OutputDebugStringW( - LPWSTR lpOutputString + LPCWSTR lpOutputString ); #ifdef UNICODE -#define OutputDebugString OutputDebugStringW +#define OutputDebugString OutputDebugStringW #else -#define OutputDebugString OutputDebugStringA +#define OutputDebugString OutputDebugStringA #endif // !UNICODE -HANDLE -APIENTRY +HRSRC +WINAPI FindResourceA( - HANDLE hModule, - LPSTR lpName, - LPSTR lpType + HINSTANCE hModule, + LPCSTR lpName, + LPCSTR lpType ); -HANDLE -APIENTRY +HRSRC +WINAPI FindResourceW( - HANDLE hModule, - LPWSTR lpName, - LPWSTR lpType + HINSTANCE hModule, + LPCWSTR lpName, + LPCWSTR lpType + ); +#ifdef UNICODE +#define FindResource FindResourceW +#else +#define FindResource FindResourceA +#endif // !UNICODE + +HRSRC +WINAPI +FindResourceExA( + HINSTANCE hModule, + LPCSTR lpType, + LPCSTR lpName, + WORD wLanguage + ); +HRSRC +WINAPI +FindResourceExW( + HINSTANCE hModule, + LPCWSTR lpType, + LPCWSTR lpName, + WORD wLanguage ); #ifdef UNICODE -#define FindResource FindResourceW +#define FindResourceEx FindResourceExW #else -#define FindResource FindResourceA +#define FindResourceEx FindResourceExA #endif // !UNICODE +#ifdef STRICT +typedef BOOL (CALLBACK* ENUMRESTYPEPROC)(HINSTANCE hModule, LPTSTR lpType, + LONG lParam); +typedef BOOL (CALLBACK* ENUMRESNAMEPROC)(HINSTANCE hModule, LPCTSTR lpType, + LPTSTR lpName, LONG lParam); +typedef BOOL (CALLBACK* ENUMRESLANGPROC)(HINSTANCE hModule, LPCTSTR lpType, + LPCTSTR lpName, WORD wLanguage, LONG lParam); +#else +typedef FARPROC ENUMRESTYPEPROC; +typedef FARPROC ENUMRESNAMEPROC; +typedef FARPROC ENUMRESLANGPROC; +#endif + BOOL -APIENTRY +WINAPI EnumResourceTypesA( - HANDLE hModule, - FARPROC lpEnumFunc, + HINSTANCE hModule, + ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); BOOL -APIENTRY +WINAPI EnumResourceTypesW( - HANDLE hModule, - FARPROC lpEnumFunc, + HINSTANCE hModule, + ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE -#define EnumResourceTypes EnumResourceTypesW +#define EnumResourceTypes EnumResourceTypesW #else -#define EnumResourceTypes EnumResourceTypesA +#define EnumResourceTypes EnumResourceTypesA #endif // !UNICODE BOOL -APIENTRY +WINAPI EnumResourceNamesA( - HANDLE hModule, - LPSTR lpType, - FARPROC lpEnumFunc, + HINSTANCE hModule, + LPCSTR lpType, + ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); BOOL -APIENTRY +WINAPI EnumResourceNamesW( - HANDLE hModule, - LPWSTR lpType, - FARPROC lpEnumFunc, + HINSTANCE hModule, + LPCWSTR lpType, + ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE -#define EnumResourceNames EnumResourceNamesW +#define EnumResourceNames EnumResourceNamesW +#else +#define EnumResourceNames EnumResourceNamesA +#endif // !UNICODE + +BOOL +WINAPI +EnumResourceLanguagesA( + HINSTANCE hModule, + LPCSTR lpType, + LPCSTR lpName, + ENUMRESLANGPROC lpEnumFunc, + LONG lParam + ); +BOOL +WINAPI +EnumResourceLanguagesW( + HINSTANCE hModule, + LPCWSTR lpType, + LPCWSTR lpName, + ENUMRESLANGPROC lpEnumFunc, + LONG lParam + ); +#ifdef UNICODE +#define EnumResourceLanguages EnumResourceLanguagesW +#else +#define EnumResourceLanguages EnumResourceLanguagesA +#endif // !UNICODE + +HANDLE +WINAPI +BeginUpdateResourceA( + LPCSTR pFileName, + BOOL bDeleteExistingResources + ); +HANDLE +WINAPI +BeginUpdateResourceW( + LPCWSTR pFileName, + BOOL bDeleteExistingResources + ); +#ifdef UNICODE +#define BeginUpdateResource BeginUpdateResourceW +#else +#define BeginUpdateResource BeginUpdateResourceA +#endif // !UNICODE + +BOOL +WINAPI +UpdateResourceA( + HANDLE hUpdate, + LPCSTR lpType, + LPCSTR lpName, + WORD wLanguage, + LPVOID lpData, + DWORD cbData + ); +BOOL +WINAPI +UpdateResourceW( + HANDLE hUpdate, + LPCWSTR lpType, + LPCWSTR lpName, + WORD wLanguage, + LPVOID lpData, + DWORD cbData + ); +#ifdef UNICODE +#define UpdateResource UpdateResourceW #else -#define EnumResourceNames EnumResourceNamesA +#define UpdateResource UpdateResourceA +#endif // !UNICODE + +BOOL +WINAPI +EndUpdateResourceA( + HANDLE hUpdate, + BOOL fDiscard + ); +BOOL +WINAPI +EndUpdateResourceW( + HANDLE hUpdate, + BOOL fDiscard + ); +#ifdef UNICODE +#define EndUpdateResource EndUpdateResourceW +#else +#define EndUpdateResource EndUpdateResourceA #endif // !UNICODE ATOM -APIENTRY +WINAPI GlobalAddAtomA( - LPSTR lpString + LPCSTR lpString ); ATOM -APIENTRY +WINAPI GlobalAddAtomW( - LPWSTR lpString + LPCWSTR lpString ); #ifdef UNICODE -#define GlobalAddAtom GlobalAddAtomW +#define GlobalAddAtom GlobalAddAtomW #else -#define GlobalAddAtom GlobalAddAtomA +#define GlobalAddAtom GlobalAddAtomA #endif // !UNICODE ATOM -APIENTRY +WINAPI GlobalFindAtomA( - LPSTR lpString + LPCSTR lpString ); ATOM -APIENTRY +WINAPI GlobalFindAtomW( - LPWSTR lpString + LPCWSTR lpString ); #ifdef UNICODE -#define GlobalFindAtom GlobalFindAtomW +#define GlobalFindAtom GlobalFindAtomW #else -#define GlobalFindAtom GlobalFindAtomA +#define GlobalFindAtom GlobalFindAtomA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, - DWORD nSize + int nSize ); -DWORD -APIENTRY +UINT +WINAPI GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, - DWORD nSize + int nSize ); #ifdef UNICODE -#define GlobalGetAtomName GlobalGetAtomNameW +#define GlobalGetAtomName GlobalGetAtomNameW #else -#define GlobalGetAtomName GlobalGetAtomNameA +#define GlobalGetAtomName GlobalGetAtomNameA #endif // !UNICODE ATOM -APIENTRY +WINAPI AddAtomA( - LPSTR lpString + LPCSTR lpString ); ATOM -APIENTRY +WINAPI AddAtomW( - LPWSTR lpString + LPCWSTR lpString ); #ifdef UNICODE -#define AddAtom AddAtomW +#define AddAtom AddAtomW #else -#define AddAtom AddAtomA +#define AddAtom AddAtomA #endif // !UNICODE ATOM -APIENTRY +WINAPI FindAtomA( - LPSTR lpString + LPCSTR lpString ); ATOM -APIENTRY +WINAPI FindAtomW( - LPWSTR lpString + LPCWSTR lpString ); #ifdef UNICODE -#define FindAtom FindAtomW +#define FindAtom FindAtomW #else -#define FindAtom FindAtomA +#define FindAtom FindAtomA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, - DWORD nSize + int nSize ); -DWORD -APIENTRY +UINT +WINAPI GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, - DWORD nSize + int nSize ); #ifdef UNICODE -#define GetAtomName GetAtomNameW +#define GetAtomName GetAtomNameW #else -#define GetAtomName GetAtomNameA +#define GetAtomName GetAtomNameA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetProfileIntA( - LPSTR lpAppName, - LPSTR lpKeyName, - DWORD nDefault + LPCSTR lpAppName, + LPCSTR lpKeyName, + INT nDefault ); -DWORD -APIENTRY +UINT +WINAPI GetProfileIntW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - DWORD nDefault + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + INT nDefault ); #ifdef UNICODE -#define GetProfileInt GetProfileIntW +#define GetProfileInt GetProfileIntW #else -#define GetProfileInt GetProfileIntA +#define GetProfileInt GetProfileIntA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetProfileStringA( - LPSTR lpAppName, - LPSTR lpKeyName, - LPSTR lpDefault, + LPCSTR lpAppName, + LPCSTR lpKeyName, + LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize ); DWORD -APIENTRY +WINAPI GetProfileStringW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - LPWSTR lpDefault, + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE -#define GetProfileString GetProfileStringW +#define GetProfileString GetProfileStringW #else -#define GetProfileString GetProfileStringA +#define GetProfileString GetProfileStringA #endif // !UNICODE BOOL -APIENTRY +WINAPI WriteProfileStringA( - LPSTR lpAppName, - LPSTR lpKeyName, - LPSTR lpString + LPCSTR lpAppName, + LPCSTR lpKeyName, + LPCSTR lpString ); BOOL -APIENTRY +WINAPI WriteProfileStringW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - LPWSTR lpString + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + LPCWSTR lpString ); #ifdef UNICODE -#define WriteProfileString WriteProfileStringW +#define WriteProfileString WriteProfileStringW #else -#define WriteProfileString WriteProfileStringA +#define WriteProfileString WriteProfileStringA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetProfileSectionA( - LPSTR lpAppName, + LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize ); DWORD -APIENTRY +WINAPI GetProfileSectionW( - LPWSTR lpAppName, + LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE -#define GetProfileSection GetProfileSectionW +#define GetProfileSection GetProfileSectionW #else -#define GetProfileSection GetProfileSectionA +#define GetProfileSection GetProfileSectionA #endif // !UNICODE -DWORD -APIENTRY +BOOL +WINAPI WriteProfileSectionA( - LPSTR lpAppName, - LPSTR lpString + LPCSTR lpAppName, + LPCSTR lpString ); -DWORD -APIENTRY +BOOL +WINAPI WriteProfileSectionW( - LPWSTR lpAppName, - LPWSTR lpString + LPCWSTR lpAppName, + LPCWSTR lpString ); #ifdef UNICODE -#define WriteProfileSection WriteProfileSectionW +#define WriteProfileSection WriteProfileSectionW #else -#define WriteProfileSection WriteProfileSectionA +#define WriteProfileSection WriteProfileSectionA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetPrivateProfileIntA( - LPSTR lpAppName, - LPSTR lpKeyName, - DWORD nDefault, - LPSTR lpFileName + LPCSTR lpAppName, + LPCSTR lpKeyName, + INT nDefault, + LPCSTR lpFileName ); -DWORD -APIENTRY +UINT +WINAPI GetPrivateProfileIntW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - DWORD nDefault, - LPWSTR lpFileName + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + INT nDefault, + LPCWSTR lpFileName ); #ifdef UNICODE -#define GetPrivateProfileInt GetPrivateProfileIntW +#define GetPrivateProfileInt GetPrivateProfileIntW #else -#define GetPrivateProfileInt GetPrivateProfileIntA +#define GetPrivateProfileInt GetPrivateProfileIntA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetPrivateProfileStringA( - LPSTR lpAppName, - LPSTR lpKeyName, - LPSTR lpDefault, + LPCSTR lpAppName, + LPCSTR lpKeyName, + LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, - LPSTR lpFileName + LPCSTR lpFileName ); DWORD -APIENTRY +WINAPI GetPrivateProfileStringW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - LPWSTR lpDefault, + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, - LPWSTR lpFileName + LPCWSTR lpFileName ); #ifdef UNICODE -#define GetPrivateProfileString GetPrivateProfileStringW +#define GetPrivateProfileString GetPrivateProfileStringW #else -#define GetPrivateProfileString GetPrivateProfileStringA +#define GetPrivateProfileString GetPrivateProfileStringA #endif // !UNICODE BOOL -APIENTRY +WINAPI WritePrivateProfileStringA( - LPSTR lpAppName, - LPSTR lpKeyName, - LPSTR lpString, - LPSTR lpFileName + LPCSTR lpAppName, + LPCSTR lpKeyName, + LPCSTR lpString, + LPCSTR lpFileName ); BOOL -APIENTRY +WINAPI WritePrivateProfileStringW( - LPWSTR lpAppName, - LPWSTR lpKeyName, - LPWSTR lpString, - LPWSTR lpFileName + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + LPCWSTR lpString, + LPCWSTR lpFileName ); #ifdef UNICODE -#define WritePrivateProfileString WritePrivateProfileStringW +#define WritePrivateProfileString WritePrivateProfileStringW #else -#define WritePrivateProfileString WritePrivateProfileStringA +#define WritePrivateProfileString WritePrivateProfileStringA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetPrivateProfileSectionA( - LPSTR lpAppName, + LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, - LPSTR lpFileName + LPCSTR lpFileName ); DWORD -APIENTRY +WINAPI GetPrivateProfileSectionW( - LPWSTR lpAppName, + LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, - LPWSTR lpFileName + LPCWSTR lpFileName ); #ifdef UNICODE -#define GetPrivateProfileSection GetPrivateProfileSectionW +#define GetPrivateProfileSection GetPrivateProfileSectionW #else -#define GetPrivateProfileSection GetPrivateProfileSectionA +#define GetPrivateProfileSection GetPrivateProfileSectionA #endif // !UNICODE -DWORD -APIENTRY +BOOL +WINAPI WritePrivateProfileSectionA( - LPSTR lpAppName, - LPSTR lpString, - LPSTR lpFileName + LPCSTR lpAppName, + LPCSTR lpString, + LPCSTR lpFileName ); -DWORD -APIENTRY +BOOL +WINAPI WritePrivateProfileSectionW( - LPWSTR lpAppName, - LPWSTR lpString, - LPWSTR lpFileName + LPCWSTR lpAppName, + LPCWSTR lpString, + LPCWSTR lpFileName ); #ifdef UNICODE -#define WritePrivateProfileSection WritePrivateProfileSectionW +#define WritePrivateProfileSection WritePrivateProfileSectionW #else -#define WritePrivateProfileSection WritePrivateProfileSectionA +#define WritePrivateProfileSection WritePrivateProfileSectionA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetDriveTypeA( - LPSTR lpRootPathName + LPCSTR lpRootPathName ); -DWORD -APIENTRY +UINT +WINAPI GetDriveTypeW( - LPWSTR lpRootPathName + LPCWSTR lpRootPathName ); #ifdef UNICODE -#define GetDriveType GetDriveTypeW +#define GetDriveType GetDriveTypeW #else -#define GetDriveType GetDriveTypeA +#define GetDriveType GetDriveTypeA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetSystemDirectoryA( LPSTR lpBuffer, - DWORD nSize + UINT uSize ); -DWORD -APIENTRY +UINT +WINAPI GetSystemDirectoryW( LPWSTR lpBuffer, - DWORD nSize + UINT uSize ); #ifdef UNICODE -#define GetSystemDirectory GetSystemDirectoryW +#define GetSystemDirectory GetSystemDirectoryW #else -#define GetSystemDirectory GetSystemDirectoryA +#define GetSystemDirectory GetSystemDirectoryA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD -APIENTRY +WINAPI GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE -#define GetTempPath GetTempPathW +#define GetTempPath GetTempPathW #else -#define GetTempPath GetTempPathA +#define GetTempPath GetTempPathA #endif // !UNICODE -WORD -APIENTRY +UINT +WINAPI GetTempFileNameA( - LPSTR lpPathName, - LPSTR lpPrefixString, - WORD wUnique, + LPCSTR lpPathName, + LPCSTR lpPrefixString, + UINT uUnique, LPSTR lpTempFileName ); -WORD -APIENTRY +UINT +WINAPI GetTempFileNameW( - LPWSTR lpPathName, - LPWSTR lpPrefixString, - WORD wUnique, + LPCWSTR lpPathName, + LPCWSTR lpPrefixString, + UINT uUnique, LPWSTR lpTempFileName ); #ifdef UNICODE -#define GetTempFileName GetTempFileNameW +#define GetTempFileName GetTempFileNameW #else -#define GetTempFileName GetTempFileNameA +#define GetTempFileName GetTempFileNameA #endif // !UNICODE -DWORD -APIENTRY +UINT +WINAPI GetWindowsDirectoryA( LPSTR lpBuffer, - DWORD nSize + UINT uSize ); -DWORD -APIENTRY +UINT +WINAPI GetWindowsDirectoryW( LPWSTR lpBuffer, - DWORD nSize + UINT uSize ); #ifdef UNICODE -#define GetWindowsDirectory GetWindowsDirectoryW +#define GetWindowsDirectory GetWindowsDirectoryW #else -#define GetWindowsDirectory GetWindowsDirectoryA +#define GetWindowsDirectory GetWindowsDirectoryA #endif // !UNICODE BOOL -APIENTRY +WINAPI SetCurrentDirectoryA( - LPSTR lpPathName + LPCSTR lpPathName ); BOOL -APIENTRY +WINAPI SetCurrentDirectoryW( - LPWSTR lpPathName + LPCWSTR lpPathName ); #ifdef UNICODE -#define SetCurrentDirectory SetCurrentDirectoryW +#define SetCurrentDirectory SetCurrentDirectoryW #else -#define SetCurrentDirectory SetCurrentDirectoryA +#define SetCurrentDirectory SetCurrentDirectoryA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD -APIENTRY +WINAPI GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE -#define GetCurrentDirectory GetCurrentDirectoryW +#define GetCurrentDirectory GetCurrentDirectoryW #else -#define GetCurrentDirectory GetCurrentDirectoryA +#define GetCurrentDirectory GetCurrentDirectoryA #endif // !UNICODE BOOL -APIENTRY +WINAPI GetDiskFreeSpaceA( - LPSTR lpRootPathName, + LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); BOOL -APIENTRY +WINAPI GetDiskFreeSpaceW( - LPWSTR lpRootPathName, + LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); #ifdef UNICODE -#define GetDiskFreeSpace GetDiskFreeSpaceW +#define GetDiskFreeSpace GetDiskFreeSpaceW #else -#define GetDiskFreeSpace GetDiskFreeSpaceA +#define GetDiskFreeSpace GetDiskFreeSpaceA #endif // !UNICODE BOOL -APIENTRY +WINAPI CreateDirectoryA( - LPSTR lpPathName, + LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); BOOL -APIENTRY +WINAPI CreateDirectoryW( - LPWSTR lpPathName, + LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE -#define CreateDirectory CreateDirectoryW +#define CreateDirectory CreateDirectoryW #else -#define CreateDirectory CreateDirectoryA +#define CreateDirectory CreateDirectoryA #endif // !UNICODE BOOL -APIENTRY +WINAPI +CreateDirectoryExA( + LPCSTR lpTemplateDirectory, + LPCSTR lpNewDirectory, + LPSECURITY_ATTRIBUTES lpSecurityAttributes + ); +BOOL +WINAPI +CreateDirectoryExW( + LPCWSTR lpTemplateDirectory, + LPCWSTR lpNewDirectory, + LPSECURITY_ATTRIBUTES lpSecurityAttributes + ); +#ifdef UNICODE +#define CreateDirectoryEx CreateDirectoryExW +#else +#define CreateDirectoryEx CreateDirectoryExA +#endif // !UNICODE + +BOOL +WINAPI RemoveDirectoryA( - LPSTR lpPathName + LPCSTR lpPathName ); BOOL -APIENTRY +WINAPI RemoveDirectoryW( - LPWSTR lpPathName + LPCWSTR lpPathName ); #ifdef UNICODE -#define RemoveDirectory RemoveDirectoryW +#define RemoveDirectory RemoveDirectoryW #else -#define RemoveDirectory RemoveDirectoryA +#define RemoveDirectory RemoveDirectoryA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetFullPathNameA( - LPSTR lpFileName, + LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); DWORD -APIENTRY +WINAPI GetFullPathNameW( - LPWSTR lpFileName, + LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart ); #ifdef UNICODE -#define GetFullPathName GetFullPathNameW +#define GetFullPathName GetFullPathNameW #else -#define GetFullPathName GetFullPathNameA +#define GetFullPathName GetFullPathNameA #endif // !UNICODE -#define EXPAND_LOCAL_DRIVES +#define DDD_RAW_TARGET_PATH 0x00000001 +#define DDD_REMOVE_DEFINITION 0x00000002 +#define DDD_EXACT_MATCH_ON_REMOVE 0x00000004 + +BOOL +WINAPI +DefineDosDeviceA( + DWORD dwFlags, + LPCSTR lpDeviceName, + LPCSTR lpTargetPath + ); +BOOL +WINAPI +DefineDosDeviceW( + DWORD dwFlags, + LPCWSTR lpDeviceName, + LPCWSTR lpTargetPath + ); +#ifdef UNICODE +#define DefineDosDevice DefineDosDeviceW +#else +#define DefineDosDevice DefineDosDeviceA +#endif // !UNICODE + +DWORD +WINAPI +QueryDosDeviceA( + LPCSTR lpDeviceName, + LPSTR lpTargetPath, + DWORD ucchMax + ); +DWORD +WINAPI +QueryDosDeviceW( + LPCWSTR lpDeviceName, + LPWSTR lpTargetPath, + DWORD ucchMax + ); +#ifdef UNICODE +#define QueryDosDevice QueryDosDeviceW +#else +#define QueryDosDevice QueryDosDeviceA +#endif // !UNICODE + +#define EXPAND_LOCAL_DRIVES HANDLE -APIENTRY +WINAPI CreateFileA( - LPSTR lpFileName, + LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, @@ -3183,9 +4047,9 @@ CreateFileA( HANDLE hTemplateFile ); HANDLE -APIENTRY +WINAPI CreateFileW( - LPWSTR lpFileName, + LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, @@ -3194,165 +4058,189 @@ CreateFileW( HANDLE hTemplateFile ); #ifdef UNICODE -#define CreateFile CreateFileW +#define CreateFile CreateFileW #else -#define CreateFile CreateFileA +#define CreateFile CreateFileA #endif // !UNICODE BOOL -APIENTRY +WINAPI SetFileAttributesA( - LPSTR lpFileName, + LPCSTR lpFileName, DWORD dwFileAttributes ); BOOL -APIENTRY +WINAPI SetFileAttributesW( - LPWSTR lpFileName, + LPCWSTR lpFileName, DWORD dwFileAttributes ); #ifdef UNICODE -#define SetFileAttributes SetFileAttributesW +#define SetFileAttributes SetFileAttributesW #else -#define SetFileAttributes SetFileAttributesA +#define SetFileAttributes SetFileAttributesA #endif // !UNICODE DWORD -APIENTRY +WINAPI GetFileAttributesA( - LPSTR lpFileName + LPCSTR lpFileName ); DWORD -APIENTRY +WINAPI GetFileAttributesW( - LPWSTR lpFileName + LPCWSTR lpFileName ); #ifdef UNICODE -#define GetFileAttributes GetFileAttributesW +#define GetFileAttributes GetFileAttributesW #else -#define GetFileAttributes GetFileAttributesA +#define GetFileAttributes GetFileAttributesA #endif // !UNICODE BOOL -APIENTRY +WINAPI DeleteFileA( - LPSTR lpFileName + LPCSTR lpFileName ); BOOL -APIENTRY +WINAPI DeleteFileW( - LPWSTR lpFileName + LPCWSTR lpFileName ); #ifdef UNICODE -#define DeleteFile DeleteFileW +#define DeleteFile DeleteFileW #else -#define DeleteFile DeleteFileA +#define DeleteFile DeleteFileA #endif // !UNICODE HANDLE -APIENTRY +WINAPI FindFirstFileA( - LPSTR lpFileName, + LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData ); HANDLE -APIENTRY +WINAPI FindFirstFileW( - LPWSTR lpFileName, + LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE -#define FindFirstFile FindFirstFileW +#define FindFirstFile FindFirstFileW #else -#define FindFirstFile FindFirstFileA +#define FindFirstFile FindFirstFileA #endif // !UNICODE BOOL -APIENTRY +WINAPI FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData ); BOOL -APIENTRY +WINAPI FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE -#define FindNextFile FindNextFileW +#define FindNextFile FindNextFileW #else -#define FindNextFile FindNextFileA +#define FindNextFile FindNextFileA #endif // !UNICODE DWORD -APIENTRY +WINAPI SearchPathA( - LPSTR lpPath, - LPSTR lpFileName, - LPSTR lpExtension, + LPCSTR lpPath, + LPCSTR lpFileName, + LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); DWORD -APIENTRY +WINAPI SearchPathW( - LPWSTR lpPath, - LPWSTR lpFileName, - LPWSTR lpExtension, + LPCWSTR lpPath, + LPCWSTR lpFileName, + LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart ); #ifdef UNICODE -#define SearchPath SearchPathW +#define SearchPath SearchPathW #else -#define SearchPath SearchPathA +#define SearchPath SearchPathA #endif // !UNICODE BOOL -APIENTRY +WINAPI CopyFileA( - LPSTR lpExistingFileName, - LPSTR lpNewFileName, + LPCSTR lpExistingFileName, + LPCSTR lpNewFileName, BOOL bFailIfExists ); BOOL -APIENTRY +WINAPI CopyFileW( - LPWSTR lpExistingFileName, - LPWSTR lpNewFileName, + LPCWSTR lpExistingFileName, + LPCWSTR lpNewFileName, BOOL bFailIfExists ); #ifdef UNICODE -#define CopyFile CopyFileW +#define CopyFile CopyFileW #else -#define CopyFile CopyFileA +#define CopyFile CopyFileA #endif // !UNICODE BOOL -APIENTRY +WINAPI MoveFileA( - LPSTR lpExistingFileName, - LPSTR lpNewFileName + LPCSTR lpExistingFileName, + LPCSTR lpNewFileName ); BOOL -APIENTRY +WINAPI MoveFileW( - LPWSTR lpExistingFileName, - LPWSTR lpNewFileName + LPCWSTR lpExistingFileName, + LPCWSTR lpNewFileName ); #ifdef UNICODE -#define MoveFile MoveFileW +#define MoveFile MoveFileW #else -#define MoveFile MoveFileA +#define MoveFile MoveFileA #endif // !UNICODE +BOOL +WINAPI +MoveFileExA( + LPCSTR lpExistingFileName, + LPCSTR lpNewFileName, + DWORD dwFlags + ); +BOOL +WINAPI +MoveFileExW( + LPCWSTR lpExistingFileName, + LPCWSTR lpNewFileName, + DWORD dwFlags + ); +#ifdef UNICODE +#define MoveFileEx MoveFileExW +#else +#define MoveFileEx MoveFileExA +#endif // !UNICODE + +#define MOVEFILE_REPLACE_EXISTING 0x00000001 +#define MOVEFILE_COPY_ALLOWED 0x00000002 +#define MOVEFILE_DELAY_UNTIL_REBOOT 0x00000004 + HANDLE -APIENTRY +WINAPI CreateNamedPipeA( - LPSTR lpName, + LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, @@ -3362,9 +4250,9 @@ CreateNamedPipeA( LPSECURITY_ATTRIBUTES lpSecurityAttributes ); HANDLE -APIENTRY +WINAPI CreateNamedPipeW( - LPWSTR lpName, + LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, @@ -3374,13 +4262,13 @@ CreateNamedPipeW( LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE -#define CreateNamedPipe CreateNamedPipeW +#define CreateNamedPipe CreateNamedPipeW #else -#define CreateNamedPipe CreateNamedPipeA +#define CreateNamedPipe CreateNamedPipeA #endif // !UNICODE BOOL -APIENTRY +WINAPI GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, @@ -3391,7 +4279,7 @@ GetNamedPipeHandleStateA( DWORD nMaxUserNameSize ); BOOL -APIENTRY +WINAPI GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, @@ -3402,15 +4290,15 @@ GetNamedPipeHandleStateW( DWORD nMaxUserNameSize ); #ifdef UNICODE -#define GetNamedPipeHandleState GetNamedPipeHandleStateW +#define GetNamedPipeHandleState GetNamedPipeHandleStateW #else -#define GetNamedPipeHandleState GetNamedPipeHandleStateA +#define GetNamedPipeHandleState GetNamedPipeHandleStateA #endif // !UNICODE BOOL -APIENTRY +WINAPI CallNamedPipeA( - LPSTR lpNamedPipeName, + LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, @@ -3419,9 +4307,9 @@ CallNamedPipeA( DWORD nTimeOut ); BOOL -APIENTRY +WINAPI CallNamedPipeW( - LPWSTR lpNamedPipeName, + LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, @@ -3430,33 +4318,55 @@ CallNamedPipeW( DWORD nTimeOut ); #ifdef UNICODE -#define CallNamedPipe CallNamedPipeW +#define CallNamedPipe CallNamedPipeW #else -#define CallNamedPipe CallNamedPipeA +#define CallNamedPipe CallNamedPipeA #endif // !UNICODE BOOL -APIENTRY +WINAPI WaitNamedPipeA( - LPSTR lpNamedPipeName, + LPCSTR lpNamedPipeName, DWORD nTimeOut ); BOOL -APIENTRY +WINAPI WaitNamedPipeW( - LPWSTR lpNamedPipeName, + LPCWSTR lpNamedPipeName, DWORD nTimeOut ); #ifdef UNICODE -#define WaitNamedPipe WaitNamedPipeW +#define WaitNamedPipe WaitNamedPipeW #else -#define WaitNamedPipe WaitNamedPipeA +#define WaitNamedPipe WaitNamedPipeA #endif // !UNICODE BOOL -APIENTRY +WINAPI +SetVolumeLabelA( + LPCSTR lpRootPathName, + LPCSTR lpVolumeName + ); +BOOL +WINAPI +SetVolumeLabelW( + LPCWSTR lpRootPathName, + LPCWSTR lpVolumeName + ); +#ifdef UNICODE +#define SetVolumeLabel SetVolumeLabelW +#else +#define SetVolumeLabel SetVolumeLabelA +#endif // !UNICODE + +VOID +WINAPI +SetFileApisToOEM( VOID ); + +BOOL +WINAPI GetVolumeInformationA( - LPSTR lpRootPathName, + LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, @@ -3466,9 +4376,9 @@ GetVolumeInformationA( DWORD nFileSystemNameSize ); BOOL -APIENTRY +WINAPI GetVolumeInformationW( - LPWSTR lpRootPathName, + LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, @@ -3478,139 +4388,1293 @@ GetVolumeInformationW( DWORD nFileSystemNameSize ); #ifdef UNICODE -#define GetVolumeInformation GetVolumeInformationW +#define GetVolumeInformation GetVolumeInformationW #else -#define GetVolumeInformation GetVolumeInformationA +#define GetVolumeInformation GetVolumeInformationA #endif // !UNICODE // -// Private MVDM apis +// Event logging APIs // -VOID -APIENTRY -VDMOperationStarted( - IN BOOL IsWowCaller +BOOL +WINAPI +ClearEventLogA ( + HANDLE hEventLog, + LPCSTR lpBackupFileName ); - BOOL -APIENTRY -GetNextVDMCommand( - PVDMINFO pVDMInfo +WINAPI +ClearEventLogW ( + HANDLE hEventLog, + LPCWSTR lpBackupFileName ); +#ifdef UNICODE +#define ClearEventLog ClearEventLogW +#else +#define ClearEventLog ClearEventLogA +#endif // !UNICODE -VOID -APIENTRY -ExitVDM( - IN BOOL IsWowCaller, - IN ULONG iWowTask - ); -// -// Event logging APIs -// BOOL -APIENTRY -ClearEventLogA ( - IN HANDLE hEventLog, - IN LPSTR lpBackupFileName +WINAPI +BackupEventLogA ( + HANDLE hEventLog, + LPCSTR lpBackupFileName ); -// -// Event logging APIs -// BOOL -APIENTRY -ClearEventLogW ( - IN HANDLE hEventLog, - IN LPWSTR lpBackupFileName +WINAPI +BackupEventLogW ( + HANDLE hEventLog, + LPCWSTR lpBackupFileName ); #ifdef UNICODE -#define ClearEventLog ClearEventLogW +#define BackupEventLog BackupEventLogW #else -#define ClearEventLog ClearEventLogA +#define BackupEventLog BackupEventLogA #endif // !UNICODE BOOL -APIENTRY +WINAPI CloseEventLog ( - IN HANDLE hEventLog + HANDLE hEventLog + ); + +BOOL +WINAPI +DeregisterEventSource ( + HANDLE hEventLog + ); + + +BOOL +WINAPI +GetNumberOfEventLogRecords ( + HANDLE hEventLog, + PDWORD NumberOfRecords + ); + +BOOL +WINAPI +GetOldestEventLogRecord ( + HANDLE hEventLog, + PDWORD OldestRecord ); HANDLE -APIENTRY +WINAPI OpenEventLogA ( - IN LPSTR lpUNCServerName, - IN LPSTR lpModuleName + LPCSTR lpUNCServerName, + LPCSTR lpSourceName ); HANDLE -APIENTRY +WINAPI OpenEventLogW ( - IN LPWSTR lpUNCServerName, - IN LPWSTR lpModuleName + LPCWSTR lpUNCServerName, + LPCWSTR lpSourceName ); #ifdef UNICODE -#define OpenEventLog OpenEventLogW +#define OpenEventLog OpenEventLogW #else -#define OpenEventLog OpenEventLogA +#define OpenEventLog OpenEventLogA +#endif // !UNICODE + +HANDLE +WINAPI +RegisterEventSourceA ( + LPCSTR lpUNCServerName, + LPCSTR lpSourceName + ); +HANDLE +WINAPI +RegisterEventSourceW ( + LPCWSTR lpUNCServerName, + LPCWSTR lpSourceName + ); +#ifdef UNICODE +#define RegisterEventSource RegisterEventSourceW +#else +#define RegisterEventSource RegisterEventSourceA +#endif // !UNICODE + +HANDLE +WINAPI +OpenBackupEventLogA ( + LPCSTR lpUNCServerName, + LPCSTR lpFileName + ); +HANDLE +WINAPI +OpenBackupEventLogW ( + LPCWSTR lpUNCServerName, + LPCWSTR lpFileName + ); +#ifdef UNICODE +#define OpenBackupEventLog OpenBackupEventLogW +#else +#define OpenBackupEventLog OpenBackupEventLogA #endif // !UNICODE BOOL -APIENTRY +WINAPI ReadEventLogA ( - IN HANDLE hEventLog, - IN DWORD dwReadFlags, - IN DWORD dwRecordOffset, - OUT LPVOID lpBuffer, - IN DWORD nNumberOfBytesToRead, - OUT DWORD *pnBytesRead, - OUT DWORD *pnMinNumberOfBytesNeeded + HANDLE hEventLog, + DWORD dwReadFlags, + DWORD dwRecordOffset, + LPVOID lpBuffer, + DWORD nNumberOfBytesToRead, + DWORD *pnBytesRead, + DWORD *pnMinNumberOfBytesNeeded ); BOOL -APIENTRY +WINAPI ReadEventLogW ( - IN HANDLE hEventLog, - IN DWORD dwReadFlags, - IN DWORD dwRecordOffset, - OUT LPVOID lpBuffer, - IN DWORD nNumberOfBytesToRead, - OUT DWORD *pnBytesRead, - OUT DWORD *pnMinNumberOfBytesNeeded + HANDLE hEventLog, + DWORD dwReadFlags, + DWORD dwRecordOffset, + LPVOID lpBuffer, + DWORD nNumberOfBytesToRead, + DWORD *pnBytesRead, + DWORD *pnMinNumberOfBytesNeeded ); #ifdef UNICODE -#define ReadEventLog ReadEventLogW +#define ReadEventLog ReadEventLogW #else -#define ReadEventLog ReadEventLogA +#define ReadEventLog ReadEventLogA #endif // !UNICODE BOOL -APIENTRY -WriteEventLogEntryA ( - IN HANDLE hEventLog, - IN WORD wType, - IN DWORD dwEventID, - IN PSID lpUserSid OPTIONAL, - IN WORD wNumStrings, - IN DWORD dwDataSize, - IN LPSTR *lpStrings OPTIONAL, - IN LPVOID lpRawData OPTIONAL +WINAPI +ReportEventA ( + HANDLE hEventLog, + WORD wType, + WORD wCategory, + DWORD dwEventID, + PSID lpUserSid, + WORD wNumStrings, + DWORD dwDataSize, + LPCSTR *lpStrings, + LPVOID lpRawData + ); +BOOL +WINAPI +ReportEventW ( + HANDLE hEventLog, + WORD wType, + WORD wCategory, + DWORD dwEventID, + PSID lpUserSid, + WORD wNumStrings, + DWORD dwDataSize, + LPCWSTR *lpStrings, + LPVOID lpRawData ); +#ifdef UNICODE +#define ReportEvent ReportEventW +#else +#define ReportEvent ReportEventA +#endif // !UNICODE + +// +// +// Security APIs +// + + +BOOL +WINAPI +DuplicateToken( + HANDLE ExistingTokenHandle, + SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, + PHANDLE DuplicateTokenHandle + ); + +BOOL +WINAPI +GetKernelObjectSecurity ( + HANDLE Handle, + SECURITY_INFORMATION RequestedInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + DWORD nLength, + LPDWORD lpnLengthNeeded + ); + +BOOL +WINAPI +ImpersonateNamedPipeClient( + HANDLE hNamedPipe + ); + +BOOL +WINAPI +ImpersonateSelf( + SECURITY_IMPERSONATION_LEVEL ImpersonationLevel + ); + + +BOOL +WINAPI +RevertToSelf ( + VOID + ); + BOOL APIENTRY -WriteEventLogEntryW ( - IN HANDLE hEventLog, - IN WORD wType, - IN DWORD dwEventID, - IN PSID lpUserSid OPTIONAL, - IN WORD wNumStrings, - IN DWORD dwDataSize, - IN LPWSTR *lpStrings OPTIONAL, - IN LPVOID lpRawData OPTIONAL +SetThreadToken ( + PHANDLE Thread, + HANDLE Token + ); + +BOOL +WINAPI +AccessCheck ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + HANDLE ClientToken, + DWORD DesiredAccess, + PGENERIC_MAPPING GenericMapping, + PPRIVILEGE_SET PrivilegeSet, + LPDWORD PrivilegeSetLength, + LPDWORD GrantedAccess, + LPBOOL AccessStatus + ); + + +BOOL +WINAPI +OpenProcessToken ( + HANDLE ProcessHandle, + DWORD DesiredAccess, + PHANDLE TokenHandle + ); + + +BOOL +WINAPI +OpenThreadToken ( + HANDLE ThreadHandle, + DWORD DesiredAccess, + BOOL OpenAsSelf, + PHANDLE TokenHandle + ); + + +BOOL +WINAPI +GetTokenInformation ( + HANDLE TokenHandle, + TOKEN_INFORMATION_CLASS TokenInformationClass, + LPVOID TokenInformation, + DWORD TokenInformationLength, + PDWORD ReturnLength + ); + + +BOOL +WINAPI +SetTokenInformation ( + HANDLE TokenHandle, + TOKEN_INFORMATION_CLASS TokenInformationClass, + LPVOID TokenInformation, + DWORD TokenInformationLength + ); + + +BOOL +WINAPI +AdjustTokenPrivileges ( + HANDLE TokenHandle, + BOOL DisableAllPrivileges, + PTOKEN_PRIVILEGES NewState, + DWORD BufferLength, + PTOKEN_PRIVILEGES PreviousState, + PDWORD ReturnLength + ); + + +BOOL +WINAPI +AdjustTokenGroups ( + HANDLE TokenHandle, + BOOL ResetToDefault, + PTOKEN_GROUPS NewState, + DWORD BufferLength, + PTOKEN_GROUPS PreviousState, + PDWORD ReturnLength + ); + + +BOOL +WINAPI +PrivilegeCheck ( + HANDLE ClientToken, + PPRIVILEGE_SET RequiredPrivileges, + LPBOOL pfResult + ); + + +BOOL +WINAPI +AccessCheckAndAuditAlarmA ( + LPCSTR SubsystemName, + LPVOID HandleId, + LPSTR ObjectTypeName, + LPSTR ObjectName, + PSECURITY_DESCRIPTOR SecurityDescriptor, + DWORD DesiredAccess, + PGENERIC_MAPPING GenericMapping, + BOOL ObjectCreation, + LPDWORD GrantedAccess, + LPBOOL AccessStatus, + LPBOOL pfGenerateOnClose + ); +BOOL +WINAPI +AccessCheckAndAuditAlarmW ( + LPCWSTR SubsystemName, + LPVOID HandleId, + LPWSTR ObjectTypeName, + LPWSTR ObjectName, + PSECURITY_DESCRIPTOR SecurityDescriptor, + DWORD DesiredAccess, + PGENERIC_MAPPING GenericMapping, + BOOL ObjectCreation, + LPDWORD GrantedAccess, + LPBOOL AccessStatus, + LPBOOL pfGenerateOnClose + ); +#ifdef UNICODE +#define AccessCheckAndAuditAlarm AccessCheckAndAuditAlarmW +#else +#define AccessCheckAndAuditAlarm AccessCheckAndAuditAlarmA +#endif // !UNICODE + + +BOOL +WINAPI +ObjectOpenAuditAlarmA ( + LPCSTR SubsystemName, + LPVOID HandleId, + LPSTR ObjectTypeName, + LPSTR ObjectName, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + HANDLE ClientToken, + DWORD DesiredAccess, + DWORD GrantedAccess, + PPRIVILEGE_SET Privileges, + BOOL ObjectCreation, + BOOL AccessGranted, + LPBOOL GenerateOnClose + ); +BOOL +WINAPI +ObjectOpenAuditAlarmW ( + LPCWSTR SubsystemName, + LPVOID HandleId, + LPWSTR ObjectTypeName, + LPWSTR ObjectName, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + HANDLE ClientToken, + DWORD DesiredAccess, + DWORD GrantedAccess, + PPRIVILEGE_SET Privileges, + BOOL ObjectCreation, + BOOL AccessGranted, + LPBOOL GenerateOnClose + ); +#ifdef UNICODE +#define ObjectOpenAuditAlarm ObjectOpenAuditAlarmW +#else +#define ObjectOpenAuditAlarm ObjectOpenAuditAlarmA +#endif // !UNICODE + + +BOOL +WINAPI +ObjectPrivilegeAuditAlarmA ( + LPCSTR SubsystemName, + LPVOID HandleId, + HANDLE ClientToken, + DWORD DesiredAccess, + PPRIVILEGE_SET Privileges, + BOOL AccessGranted + ); +BOOL +WINAPI +ObjectPrivilegeAuditAlarmW ( + LPCWSTR SubsystemName, + LPVOID HandleId, + HANDLE ClientToken, + DWORD DesiredAccess, + PPRIVILEGE_SET Privileges, + BOOL AccessGranted + ); +#ifdef UNICODE +#define ObjectPrivilegeAuditAlarm ObjectPrivilegeAuditAlarmW +#else +#define ObjectPrivilegeAuditAlarm ObjectPrivilegeAuditAlarmA +#endif // !UNICODE + + +BOOL +WINAPI +ObjectCloseAuditAlarmA ( + LPCSTR SubsystemName, + LPVOID HandleId, + BOOL GenerateOnClose + ); +BOOL +WINAPI +ObjectCloseAuditAlarmW ( + LPCWSTR SubsystemName, + LPVOID HandleId, + BOOL GenerateOnClose + ); +#ifdef UNICODE +#define ObjectCloseAuditAlarm ObjectCloseAuditAlarmW +#else +#define ObjectCloseAuditAlarm ObjectCloseAuditAlarmA +#endif // !UNICODE + + +BOOL +WINAPI +PrivilegedServiceAuditAlarmA ( + LPCSTR SubsystemName, + LPCSTR ServiceName, + HANDLE ClientToken, + PPRIVILEGE_SET Privileges, + BOOL AccessGranted + ); +BOOL +WINAPI +PrivilegedServiceAuditAlarmW ( + LPCWSTR SubsystemName, + LPCWSTR ServiceName, + HANDLE ClientToken, + PPRIVILEGE_SET Privileges, + BOOL AccessGranted + ); +#ifdef UNICODE +#define PrivilegedServiceAuditAlarm PrivilegedServiceAuditAlarmW +#else +#define PrivilegedServiceAuditAlarm PrivilegedServiceAuditAlarmA +#endif // !UNICODE + + +BOOL +WINAPI +IsValidSid ( + PSID pSid + ); + + +BOOL +WINAPI +EqualSid ( + PSID pSid1, + PSID pSid2 + ); + + +BOOL +WINAPI +EqualPrefixSid ( + PSID pSid1, + PSID pSid2 + ); + + +DWORD +WINAPI +GetSidLengthRequired ( + UCHAR nSubAuthorityCount + ); + + +BOOL +WINAPI +AllocateAndInitializeSid ( + PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, + BYTE nSubAuthorityCount, + DWORD nSubAuthority0, + DWORD nSubAuthority1, + DWORD nSubAuthority2, + DWORD nSubAuthority3, + DWORD nSubAuthority4, + DWORD nSubAuthority5, + DWORD nSubAuthority6, + DWORD nSubAuthority7, + PSID *pSid + ); + +PVOID +WINAPI +FreeSid( + PSID pSid + ); + +BOOL +WINAPI +InitializeSid ( + PSID Sid, + PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, + BYTE nSubAuthorityCount + ); + + +PSID_IDENTIFIER_AUTHORITY +WINAPI +GetSidIdentifierAuthority ( + PSID pSid + ); + + +PDWORD +WINAPI +GetSidSubAuthority ( + PSID pSid, + DWORD nSubAuthority + ); + + +PUCHAR +WINAPI +GetSidSubAuthorityCount ( + PSID pSid + ); + + +DWORD +WINAPI +GetLengthSid ( + PSID pSid + ); + + +BOOL +WINAPI +CopySid ( + DWORD nDestinationSidLength, + PSID pDestinationSid, + PSID pSourceSid + ); + + +BOOL +WINAPI +AreAllAccessesGranted ( + DWORD GrantedAccess, + DWORD DesiredAccess + ); + + +BOOL +WINAPI +AreAnyAccessesGranted ( + DWORD GrantedAccess, + DWORD DesiredAccess + ); + + +VOID +WINAPI +MapGenericMask ( + PDWORD AccessMask, + PGENERIC_MAPPING GenericMapping + ); + + +BOOL +WINAPI +IsValidAcl ( + PACL pAcl + ); + + +BOOL +WINAPI +InitializeAcl ( + PACL pAcl, + DWORD nAclLength, + DWORD dwAclRevision + ); + + +BOOL +WINAPI +GetAclInformation ( + PACL pAcl, + LPVOID pAclInformation, + DWORD nAclInformationLength, + ACL_INFORMATION_CLASS dwAclInformationClass + ); + + +BOOL +WINAPI +SetAclInformation ( + PACL pAcl, + LPVOID pAclInformation, + DWORD nAclInformationLength, + ACL_INFORMATION_CLASS dwAclInformationClass + ); + + +BOOL +WINAPI +AddAce ( + PACL pAcl, + DWORD dwAceRevision, + DWORD dwStartingAceIndex, + LPVOID pAceList, + DWORD nAceListLength + ); + + +BOOL +WINAPI +DeleteAce ( + PACL pAcl, + DWORD dwAceIndex + ); + + +BOOL +WINAPI +GetAce ( + PACL pAcl, + DWORD dwAceIndex, + LPVOID *pAce + ); + + +BOOL +WINAPI +AddAccessAllowedAce ( + PACL pAcl, + DWORD dwAceRevision, + DWORD AccessMask, + PSID pSid + ); + + +BOOL +WINAPI +AddAccessDeniedAce ( + PACL pAcl, + DWORD dwAceRevision, + DWORD AccessMask, + PSID pSid + ); + + +BOOL +WINAPI +AddAuditAccessAce( + PACL pAcl, + DWORD dwAceRevision, + DWORD dwAccessMask, + PSID pSid, + BOOL bAuditSuccess, + BOOL bAuditFailure + ); + + +BOOL +WINAPI +FindFirstFreeAce ( + PACL pAcl, + LPVOID *pAce + ); + + +BOOL +WINAPI +InitializeSecurityDescriptor ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + DWORD dwRevision + ); + + +BOOL +WINAPI +IsValidSecurityDescriptor ( + PSECURITY_DESCRIPTOR pSecurityDescriptor + ); + + +DWORD +WINAPI +GetSecurityDescriptorLength ( + PSECURITY_DESCRIPTOR pSecurityDescriptor + ); + + +BOOL +WINAPI +GetSecurityDescriptorControl ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + PSECURITY_DESCRIPTOR_CONTROL pControl, + LPDWORD lpdwRevision + ); + + +BOOL +WINAPI +SetSecurityDescriptorDacl ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + BOOL bDaclPresent, + PACL pDacl, + BOOL bDaclDefaulted + ); + + +BOOL +WINAPI +GetSecurityDescriptorDacl ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + LPBOOL lpbDaclPresent, + PACL *pDacl, + LPBOOL lpbDaclDefaulted + ); + + +BOOL +WINAPI +SetSecurityDescriptorSacl ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + BOOL bSaclPresent, + PACL pSacl, + BOOL bSaclDefaulted + ); + + +BOOL +WINAPI +GetSecurityDescriptorSacl ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + LPBOOL lpbSaclPresent, + PACL *pSacl, + LPBOOL lpbSaclDefaulted + ); + + +BOOL +WINAPI +SetSecurityDescriptorOwner ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + PSID pOwner, + BOOL bOwnerDefaulted + ); + + +BOOL +WINAPI +GetSecurityDescriptorOwner ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + PSID *pOwner, + LPBOOL lpbOwnerDefaulted + ); + + +BOOL +WINAPI +SetSecurityDescriptorGroup ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + PSID pGroup, + BOOL bGroupDefaulted + ); + + +BOOL +WINAPI +GetSecurityDescriptorGroup ( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + PSID *pGroup, + LPBOOL lpbGroupDefaulted + ); + + +BOOL +WINAPI +CreatePrivateObjectSecurity ( + PSECURITY_DESCRIPTOR ParentDescriptor, + PSECURITY_DESCRIPTOR CreatorDescriptor, + PSECURITY_DESCRIPTOR * NewDescriptor, + BOOL IsDirectoryObject, + HANDLE Token, + PGENERIC_MAPPING GenericMapping + ); + + +BOOL +WINAPI +SetPrivateObjectSecurity ( + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR ModificationDescriptor, + PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, + PGENERIC_MAPPING GenericMapping, + HANDLE Token + ); + + +BOOL +WINAPI +GetPrivateObjectSecurity ( + PSECURITY_DESCRIPTOR ObjectDescriptor, + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR ResultantDescriptor, + DWORD DescriptorLength, + PDWORD ReturnLength + ); + + +BOOL +WINAPI +DestroyPrivateObjectSecurity ( + PSECURITY_DESCRIPTOR * ObjectDescriptor + ); + + +BOOL +WINAPI +MakeSelfRelativeSD ( + PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, + PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, + LPDWORD lpdwBufferLength + ); + + +BOOL +WINAPI +MakeAbsoluteSD ( + PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, + PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, + LPDWORD lpdwAbsoluteSecurityDescriptorSize, + PACL pDacl, + LPDWORD lpdwDaclSize, + PACL pSacl, + LPDWORD lpdwSaclSize, + PSID pOwner, + LPDWORD lpdwOwnerSize, + PSID pPrimaryGroup, + LPDWORD lpdwPrimaryGroupSize + ); + + +BOOL +WINAPI +SetFileSecurityA ( + LPCSTR lpFileName, + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor + ); +BOOL +WINAPI +SetFileSecurityW ( + LPCWSTR lpFileName, + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor ); #ifdef UNICODE -#define WriteEventLogEntry WriteEventLogEntryW +#define SetFileSecurity SetFileSecurityW #else -#define WriteEventLogEntry WriteEventLogEntryA +#define SetFileSecurity SetFileSecurityA #endif // !UNICODE + + +BOOL +WINAPI +GetFileSecurityA ( + LPCSTR lpFileName, + SECURITY_INFORMATION RequestedInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + DWORD nLength, + LPDWORD lpnLengthNeeded + ); +BOOL +WINAPI +GetFileSecurityW ( + LPCWSTR lpFileName, + SECURITY_INFORMATION RequestedInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + DWORD nLength, + LPDWORD lpnLengthNeeded + ); +#ifdef UNICODE +#define GetFileSecurity GetFileSecurityW +#else +#define GetFileSecurity GetFileSecurityA +#endif // !UNICODE + + +BOOL +WINAPI +SetKernelObjectSecurity ( + HANDLE Handle, + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR SecurityDescriptor + ); + + + +HANDLE +WINAPI +FindFirstChangeNotificationA( + LPCSTR lpPathName, + BOOL bWatchSubtree, + DWORD dwNotifyFilter + ); +HANDLE +WINAPI +FindFirstChangeNotificationW( + LPCWSTR lpPathName, + BOOL bWatchSubtree, + DWORD dwNotifyFilter + ); +#ifdef UNICODE +#define FindFirstChangeNotification FindFirstChangeNotificationW +#else +#define FindFirstChangeNotification FindFirstChangeNotificationA +#endif // !UNICODE +BOOL +WINAPI +FindNextChangeNotification( + HANDLE hChangeHandle + ); + +BOOL +WINAPI +FindCloseChangeNotification( + HANDLE hChangeHandle + ); + +BOOL +WINAPI +VirtualLock( + LPVOID lpAddress, + DWORD dwSize + ); + +BOOL +WINAPI +VirtualUnlock( + LPVOID lpAddress, + DWORD dwSize + ); + +LPVOID +WINAPI +MapViewOfFileEx( + HANDLE hFileMappingObject, + DWORD dwDesiredAccess, + DWORD dwFileOffsetHigh, + DWORD dwFileOffsetLow, + DWORD dwNumberOfBytesToMap, + LPVOID lpBaseAddress + ); + +BOOL +WINAPI +SetPriorityClass( + HANDLE hProcess, + DWORD dwPriorityClass + ); + +DWORD +WINAPI +GetPriorityClass( + HANDLE hProcess + ); + +BOOL +WINAPI +IsBadReadPtr( + CONST VOID *lp, + UINT ucb + ); + +BOOL +WINAPI +IsBadWritePtr( + LPVOID lp, + UINT ucb + ); + +BOOL +WINAPI +IsBadHugeReadPtr( + CONST VOID *lp, + UINT ucb + ); + +BOOL +WINAPI +IsBadHugeWritePtr( + LPVOID lp, + UINT ucb + ); + +BOOL +WINAPI +IsBadCodePtr( + FARPROC lpfn + ); + +BOOL +WINAPI +IsBadStringPtrA( + LPCSTR lpsz, + UINT ucchMax + ); +BOOL +WINAPI +IsBadStringPtrW( + LPCWSTR lpsz, + UINT ucchMax + ); +#ifdef UNICODE +#define IsBadStringPtr IsBadStringPtrW +#else +#define IsBadStringPtr IsBadStringPtrA +#endif // !UNICODE + +BOOL +WINAPI +LookupAccountSidA( + LPCSTR lpSystemName, + PSID Sid, + LPSTR Name, + LPDWORD cbName, + LPSTR ReferencedDomainName, + LPDWORD cbReferencedDomainName, + PSID_NAME_USE peUse + ); +BOOL +WINAPI +LookupAccountSidW( + LPCWSTR lpSystemName, + PSID Sid, + LPWSTR Name, + LPDWORD cbName, + LPWSTR ReferencedDomainName, + LPDWORD cbReferencedDomainName, + PSID_NAME_USE peUse + ); +#ifdef UNICODE +#define LookupAccountSid LookupAccountSidW +#else +#define LookupAccountSid LookupAccountSidA +#endif // !UNICODE + +BOOL +WINAPI +LookupAccountNameA( + LPCSTR lpSystemName, + LPCSTR lpAccountName, + PSID Sid, + LPDWORD cbSid, + LPSTR ReferencedDomainName, + LPDWORD cbReferencedDomainName, + PSID_NAME_USE peUse + ); +BOOL +WINAPI +LookupAccountNameW( + LPCWSTR lpSystemName, + LPCWSTR lpAccountName, + PSID Sid, + LPDWORD cbSid, + LPWSTR ReferencedDomainName, + LPDWORD cbReferencedDomainName, + PSID_NAME_USE peUse + ); +#ifdef UNICODE +#define LookupAccountName LookupAccountNameW +#else +#define LookupAccountName LookupAccountNameA +#endif // !UNICODE + +BOOL +WINAPI +LookupPrivilegeValueA( + LPCSTR lpSystemName, + LPCSTR lpName, + PLUID lpLuid + ); +BOOL +WINAPI +LookupPrivilegeValueW( + LPCWSTR lpSystemName, + LPCWSTR lpName, + PLUID lpLuid + ); +#ifdef UNICODE +#define LookupPrivilegeValue LookupPrivilegeValueW +#else +#define LookupPrivilegeValue LookupPrivilegeValueA +#endif // !UNICODE + +BOOL +WINAPI +LookupPrivilegeNameA( + LPCSTR lpSystemName, + PLUID lpLuid, + LPSTR lpName, + LPDWORD cbName + ); +BOOL +WINAPI +LookupPrivilegeNameW( + LPCWSTR lpSystemName, + PLUID lpLuid, + LPWSTR lpName, + LPDWORD cbName + ); +#ifdef UNICODE +#define LookupPrivilegeName LookupPrivilegeNameW +#else +#define LookupPrivilegeName LookupPrivilegeNameA +#endif // !UNICODE + +BOOL +WINAPI +LookupPrivilegeDisplayNameA( + LPCSTR lpSystemName, + LPCSTR lpName, + LPSTR lpDisplayName, + LPDWORD cbDisplayName, + LPDWORD lpLanguageId + ); +BOOL +WINAPI +LookupPrivilegeDisplayNameW( + LPCWSTR lpSystemName, + LPCWSTR lpName, + LPWSTR lpDisplayName, + LPDWORD cbDisplayName, + LPDWORD lpLanguageId + ); +#ifdef UNICODE +#define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameW +#else +#define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameA +#endif // !UNICODE + +BOOL +WINAPI +AllocateLocallyUniqueId( + PLUID Luid + ); + +BOOL +WINAPI +BuildCommDCBA( + LPCSTR lpDef, + LPDCB lpDCB + ); +BOOL +WINAPI +BuildCommDCBW( + LPCWSTR lpDef, + LPDCB lpDCB + ); +#ifdef UNICODE +#define BuildCommDCB BuildCommDCBW +#else +#define BuildCommDCB BuildCommDCBA +#endif // !UNICODE + +BOOL +WINAPI +BuildCommDCBAndTimeoutsA( + LPCSTR lpDef, + LPDCB lpDCB, + LPCOMMTIMEOUTS lpCommTimeouts + ); +BOOL +WINAPI +BuildCommDCBAndTimeoutsW( + LPCWSTR lpDef, + LPDCB lpDCB, + LPCOMMTIMEOUTS lpCommTimeouts + ); +#ifdef UNICODE +#define BuildCommDCBAndTimeouts BuildCommDCBAndTimeoutsW +#else +#define BuildCommDCBAndTimeouts BuildCommDCBAndTimeoutsA +#endif // !UNICODE + +#define MAX_COMPUTERNAME_LENGTH 15 + +BOOL +WINAPI +GetComputerNameA ( + LPSTR lpBuffer, + LPDWORD nSize + ); +BOOL +WINAPI +GetComputerNameW ( + LPWSTR lpBuffer, + LPDWORD nSize + ); +#ifdef UNICODE +#define GetComputerName GetComputerNameW +#else +#define GetComputerName GetComputerNameA +#endif // !UNICODE + +BOOL +WINAPI +SetComputerNameA ( + LPCSTR lpComputerName + ); +BOOL +WINAPI +SetComputerNameW ( + LPCWSTR lpComputerName + ); +#ifdef UNICODE +#define SetComputerName SetComputerNameW +#else +#define SetComputerName SetComputerNameA +#endif // !UNICODE + +BOOL +WINAPI +GetUserNameA ( + LPSTR lpBuffer, + LPDWORD nSize + ); +BOOL +WINAPI +GetUserNameW ( + LPWSTR lpBuffer, + LPDWORD nSize + ); +#ifdef UNICODE +#define GetUserName GetUserNameW +#else +#define GetUserName GetUserNameA +#endif // !UNICODE + +// +// Performance counter API's // + +BOOL +WINAPI +QueryPerformanceCounter( + LARGE_INTEGER *lpPerformanceCount + ); + +BOOL +WINAPI +QueryPerformanceFrequency( + LARGE_INTEGER *lpFrequency + ); + + // DOS and OS/2 Compatible Error Code definitions returned by the Win32 Base // API functions. // @@ -3624,4 +5688,8 @@ WriteEventLogEntryW ( #define TC_GP_TRAP 2 #define TC_SIGNAL 3 +#ifdef __cplusplus +} +#endif + #endif // _WINBASE_