Tricks of the Windows Game Programming Gurus (2nd Edition)

home *** CD-ROM | disk | FTP | other *** search

/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / winbase.h < prev next >

Wrap

C/C++ Source or Header | 1998-04-25 | 174KB | 8,620 lines

/************************************************************************ * * * winbase.h -- This module defines the 32-Bit Windows Base APIs * * * * Copyright 1990 - 1998 Microsoft Corp. All rights reserved. * * * ************************************************************************/ #ifndef _WINBASE_ #define _WINBASE_ #ifdef _MAC #include <macwin32.h> #endif //_MAC // // Define API decoration for direct importing of DLL references. // #if !defined(_ADVAPI32_) #define WINADVAPI DECLSPEC_IMPORT #else #define WINADVAPI #endif #if !defined(_KERNEL32_) #define WINBASEAPI DECLSPEC_IMPORT #else #define WINBASEAPI #endif #if !defined(_ZAWPROXY_) #define ZAWPROXYAPI DECLSPEC_IMPORT #else #define ZAWPROXYAPI #endif #ifdef __cplusplus extern "C" { #endif /* * Compatibility macros */ #define DefineHandleTable(w) ((w),TRUE) #define LimitEmsPages(dw) #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 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 EXCEPTION_GUARD_PAGE STATUS_GUARD_PAGE_VIOLATION #define EXCEPTION_INVALID_HANDLE STATUS_INVALID_HANDLE #define CONTROL_C_EXIT STATUS_CONTROL_C_EXIT #define MoveMemory RtlMoveMemory #define CopyMemory RtlCopyMemory #define FillMemory RtlFillMemory #define ZeroMemory RtlZeroMemory #if (_WIN32_WINNT >= 0x0500) #if defined(_M_ALPHA) #define MoveMemoryVlm RtlMoveMemory #define CopyMemoryVlm RtlCopyMemory #define FillMemoryVlm RtlFillMemory #define ZeroMemoryVlm RtlZeroMemory #endif #endif // // File creation flags must start at the high end since they // are combined with the attributes // #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 FILE_FLAG_OPEN_REPARSE_POINT 0x00200000 #define FILE_FLAG_OPEN_NO_RECALL 0x00100000 #define CREATE_NEW 1 #define CREATE_ALWAYS 2 #define OPEN_EXISTING 3 #define OPEN_ALWAYS 4 #define TRUNCATE_EXISTING 5 #if(_WIN32_WINNT >= 0x0400) // // Define possible return codes from the CopyFileEx callback routine // #define PROGRESS_CONTINUE 0 #define PROGRESS_CANCEL 1 #define PROGRESS_STOP 2 #define PROGRESS_QUIET 3 // // Define CopyFileEx callback routine state change values // #define CALLBACK_CHUNK_FINISHED 0x00000000 #define CALLBACK_STREAM_SWITCH 0x00000001 // // Define CopyFileEx option flags // #define COPY_FILE_FAIL_IF_EXISTS 0x00000001 #define COPY_FILE_RESTARTABLE 0x00000002 #define COPY_FILE_OPEN_SOURCE_FOR_WRITE 0x00000004 #endif /* _WIN32_WINNT >= 0x0400 */ // // Define the NamedPipe definitions // // // Define the dwOpenMode values for CreateNamedPipe // #define PIPE_ACCESS_INBOUND 0x00000001 #define PIPE_ACCESS_OUTBOUND 0x00000002 #define PIPE_ACCESS_DUPLEX 0x00000003 // // Define the Named Pipe End flags for GetNamedPipeInfo // #define PIPE_CLIENT_END 0x00000000 #define PIPE_SERVER_END 0x00000001 // // Define the dwPipeMode values for CreateNamedPipe // #define PIPE_WAIT 0x00000000 #define PIPE_NOWAIT 0x00000001 #define PIPE_READMODE_BYTE 0x00000000 #define PIPE_READMODE_MESSAGE 0x00000002 #define PIPE_TYPE_BYTE 0x00000000 #define PIPE_TYPE_MESSAGE 0x00000004 // // Define the well known values for CreateNamedPipe nMaxInstances // #define PIPE_UNLIMITED_INSTANCES 255 // // Define the Security Quality of Service bits to be passed // into CreateFile // #define SECURITY_ANONYMOUS ( SecurityAnonymous << 16 ) #define SECURITY_IDENTIFICATION ( SecurityIdentification << 16 ) #define SECURITY_IMPERSONATION ( SecurityImpersonation << 16 ) #define SECURITY_DELEGATION ( SecurityDelegation << 16 ) #define SECURITY_CONTEXT_TRACKING 0x00040000 #define SECURITY_EFFECTIVE_ONLY 0x00080000 #define SECURITY_SQOS_PRESENT 0x00100000 #define SECURITY_VALID_SQOS_FLAGS 0x001F0000 // // File structures // typedef struct _OVERLAPPED { DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; HANDLE hEvent; } OVERLAPPED, *LPOVERLAPPED; typedef struct _SECURITY_ATTRIBUTES { DWORD nLength; LPVOID lpSecurityDescriptor; BOOL bInheritHandle; } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES; typedef struct _PROCESS_INFORMATION { HANDLE hProcess; HANDLE hThread; DWORD dwProcessId; DWORD dwThreadId; } PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION; // // File System time stamps are represented with the following structure: // typedef struct _FILETIME { DWORD dwLowDateTime; DWORD dwHighDateTime; } FILETIME, *PFILETIME, *LPFILETIME; // // System time is represented with the following structure: // typedef struct _SYSTEMTIME { WORD wYear; WORD wMonth; WORD wDayOfWeek; WORD wDay; WORD wHour; WORD wMinute; WORD wSecond; WORD wMilliseconds; } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME; typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)( LPVOID lpThreadParameter ); typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; #if(_WIN32_WINNT >= 0x0400) typedef VOID (WINAPI *PFIBER_START_ROUTINE)( LPVOID lpFiberParameter ); typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE; #endif /* _WIN32_WINNT >= 0x0400 */ typedef RTL_CRITICAL_SECTION CRITICAL_SECTION; typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION; typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION; 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; #endif #define MUTEX_MODIFY_STATE MUTANT_QUERY_STATE #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_MODEM ((DWORD)0x00000006) #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_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. // #define SP_PARITY ((DWORD)0x0001) #define SP_BAUD ((DWORD)0x0002) #define SP_DATABITS ((DWORD)0x0004) #define SP_STOPBITS ((DWORD)0x0008) #define SP_HANDSHAKING ((DWORD)0x0010) #define SP_PARITY_CHECK ((DWORD)0x0020) #define SP_RLSD ((DWORD)0x0040) // // Settable baud rates in the provider. // #define BAUD_075 ((DWORD)0x00000001) #define BAUD_110 ((DWORD)0x00000002) #define BAUD_134_5 ((DWORD)0x00000004) #define BAUD_150 ((DWORD)0x00000008) #define BAUD_300 ((DWORD)0x00000010) #define BAUD_600 ((DWORD)0x00000020) #define BAUD_1200 ((DWORD)0x00000040) #define BAUD_1800 ((DWORD)0x00000080) #define BAUD_2400 ((DWORD)0x00000100) #define BAUD_4800 ((DWORD)0x00000200) #define BAUD_7200 ((DWORD)0x00000400) #define BAUD_9600 ((DWORD)0x00000800) #define BAUD_14400 ((DWORD)0x00001000) #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) // // Settable Data Bits // #define DATABITS_5 ((WORD)0x0001) #define DATABITS_6 ((WORD)0x0002) #define DATABITS_7 ((WORD)0x0004) #define DATABITS_8 ((WORD)0x0008) #define DATABITS_16 ((WORD)0x0010) #define DATABITS_16X ((WORD)0x0020) // // Settable Stop and Parity bits. // #define STOPBITS_10 ((WORD)0x0001) #define STOPBITS_15 ((WORD)0x0002) #define STOPBITS_20 ((WORD)0x0004) #define PARITY_NONE ((WORD)0x0100) #define PARITY_ODD ((WORD)0x0200) #define PARITY_EVEN ((WORD)0x0400) #define PARITY_MARK ((WORD)0x0800) #define PARITY_SPACE ((WORD)0x1000) typedef struct _COMMPROP { WORD wPacketLength; WORD wPacketVersion; DWORD dwServiceMask; DWORD dwReserved1; DWORD dwMaxTxQueue; DWORD dwMaxRxQueue; DWORD dwMaxBaud; DWORD dwProvSubType; DWORD dwProvCapabilities; DWORD dwSettableParams; DWORD dwSettableBaud; WORD wSettableData; WORD wSettableStopParity; DWORD dwCurrentTxQueue; DWORD dwCurrentRxQueue; DWORD dwProvSpec1; DWORD dwProvSpec2; WCHAR wcProvChar[1]; } COMMPROP,*LPCOMMPROP; // // Set dwProvSpec1 to COMMPROP_INITIALIZED to indicate that wPacketLength // is valid before a call to GetCommProperties(). // #define COMMPROP_INITIALIZED ((DWORD)0xE73CF52E) typedef struct _COMSTAT { DWORD fCtsHold : 1; DWORD fDsrHold : 1; DWORD fRlsdHold : 1; DWORD fXoffHold : 1; DWORD fXoffSent : 1; DWORD fEof : 1; DWORD fTxim : 1; DWORD fReserved : 25; DWORD cbInQue; DWORD cbOutQue; } COMSTAT, *LPCOMSTAT; // // DTR Control Flow Values. // #define DTR_CONTROL_DISABLE 0x00 #define DTR_CONTROL_ENABLE 0x01 #define DTR_CONTROL_HANDSHAKE 0x02 // // RTS Control Flow Values // #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) */ DWORD BaudRate; /* Baudrate at which running */ DWORD fBinary: 1; /* Binary Mode (skip EOF check) */ DWORD fParity: 1; /* Enable parity checking */ DWORD fOutxCtsFlow:1; /* CTS handshaking on output */ DWORD fOutxDsrFlow:1; /* DSR handshaking on output */ DWORD fDtrControl:2; /* DTR Flow control */ 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 fErrorChar: 1; /* Enable Err Replacement */ DWORD fNull: 1; /* Enable Null stripping */ DWORD fRtsControl:2; /* Rts Flow control */ 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 */ BYTE Parity; /* 0-4=None,Odd,Even,Mark,Space */ 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 ErrorChar; /* Error replacement char */ char EofChar; /* End of Input character */ char EvtChar; /* Received Event character */ WORD wReserved1; /* Fill for now. */ } DCB, *LPDCB; typedef struct _COMMTIMEOUTS { DWORD ReadIntervalTimeout; /* Maximum time between read chars. */ DWORD ReadTotalTimeoutMultiplier; /* Multiplier of characters. */ DWORD ReadTotalTimeoutConstant; /* Constant in milliseconds. */ DWORD WriteTotalTimeoutMultiplier; /* Multiplier of characters. */ DWORD WriteTotalTimeoutConstant; /* Constant in milliseconds. */ } COMMTIMEOUTS,*LPCOMMTIMEOUTS; typedef struct _COMMCONFIG { DWORD dwSize; /* Size of the entire struct */ WORD wVersion; /* version of the structure */ WORD wReserved; /* alignment */ DCB dcb; /* device control block */ DWORD dwProviderSubType; /* ordinal value for identifying provider-defined data structure format*/ DWORD dwProviderOffset; /* Specifies the offset of provider specific data field in bytes from the start */ DWORD dwProviderSize; /* size of the provider-specific data field */ WCHAR wcProviderData[1]; /* provider-specific data */ } COMMCONFIG,*LPCOMMCONFIG; typedef struct _SYSTEM_INFO { union { DWORD dwOemId; // Obsolete field...do not use struct { WORD wProcessorArchitecture; WORD wReserved; }; }; DWORD dwPageSize; LPVOID lpMinimumApplicationAddress; LPVOID lpMaximumApplicationAddress; DWORD dwActiveProcessorMask; DWORD dwNumberOfProcessors; DWORD dwProcessorType; DWORD dwAllocationGranularity; WORD wProcessorLevel; WORD wProcessorRevision; } SYSTEM_INFO, *LPSYSTEM_INFO; // // #define FreeModule(hLibModule) FreeLibrary((hLibModule)) #define MakeProcInstance(lpProc,hInstance) (lpProc) #define FreeProcInstance(lpProc) (lpProc) /* Global Memory Flags */ #define GMEM_FIXED 0x0000 #define GMEM_MOVEABLE 0x0002 #define GMEM_NOCOMPACT 0x0010 #define GMEM_NODISCARD 0x0020 #define GMEM_ZEROINIT 0x0040 #define GMEM_MODIFY 0x0080 #define GMEM_DISCARDABLE 0x0100 #define GMEM_NOT_BANKED 0x1000 #define GMEM_SHARE 0x2000 #define GMEM_DDESHARE 0x2000 #define GMEM_NOTIFY 0x4000 #define GMEM_LOWER GMEM_NOT_BANKED #define GMEM_VALID_FLAGS 0x7F72 #define GMEM_INVALID_HANDLE 0x8000 #define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT) #define GPTR (GMEM_FIXED | GMEM_ZEROINIT) #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 #define GMEM_LOCKCOUNT 0x00FF typedef struct _MEMORYSTATUS { DWORD dwLength; DWORD dwMemoryLoad; DWORD dwTotalPhys; DWORD dwAvailPhys; DWORD dwTotalPageFile; DWORD dwAvailPageFile; DWORD dwTotalVirtual; DWORD dwAvailVirtual; } MEMORYSTATUS, *LPMEMORYSTATUS; /* Local Memory Flags */ #define LMEM_FIXED 0x0000 #define LMEM_MOVEABLE 0x0002 #define LMEM_NOCOMPACT 0x0010 #define LMEM_NODISCARD 0x0020 #define LMEM_ZEROINIT 0x0040 #define LMEM_MODIFY 0x0080 #define LMEM_DISCARDABLE 0x0F00 #define LMEM_VALID_FLAGS 0x0F72 #define LMEM_INVALID_HANDLE 0x8000 #define LHND (LMEM_MOVEABLE | LMEM_ZEROINIT) #define LPTR (LMEM_FIXED | LMEM_ZEROINIT) #define NONZEROLHND (LMEM_MOVEABLE) #define NONZEROLPTR (LMEM_FIXED) #define LocalDiscard( h ) LocalReAlloc( (h), 0, LMEM_MOVEABLE ) /* Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE) */ #define LMEM_DISCARDED 0x4000 #define LMEM_LOCKCOUNT 0x00FF // // dwCreationFlag values // #define DEBUG_PROCESS 0x00000001 #define DEBUG_ONLY_THIS_PROCESS 0x00000002 #define CREATE_SUSPENDED 0x00000004 #define DETACHED_PROCESS 0x00000008 #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_UNICODE_ENVIRONMENT 0x00000400 #define CREATE_SEPARATE_WOW_VDM 0x00000800 #define CREATE_SHARED_WOW_VDM 0x00001000 #define CREATE_FORCEDOS 0x00002000 #define CREATE_DEFAULT_ERROR_MODE 0x04000000 #define CREATE_NO_WINDOW 0x08000000 #define PROFILE_USER 0x10000000 #define PROFILE_KERNEL 0x20000000 #define PROFILE_SERVER 0x40000000 #define THREAD_PRIORITY_LOWEST THREAD_BASE_PRIORITY_MIN #define THREAD_PRIORITY_BELOW_NORMAL (THREAD_PRIORITY_LOWEST+1) #define THREAD_PRIORITY_NORMAL 0 #define THREAD_PRIORITY_HIGHEST THREAD_BASE_PRIORITY_MAX #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 // #define EXCEPTION_DEBUG_EVENT 1 #define CREATE_THREAD_DEBUG_EVENT 2 #define CREATE_PROCESS_DEBUG_EVENT 3 #define EXIT_THREAD_DEBUG_EVENT 4 #define EXIT_PROCESS_DEBUG_EVENT 5 #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; DWORD dwFirstChance; } EXCEPTION_DEBUG_INFO, *LPEXCEPTION_DEBUG_INFO; typedef struct _CREATE_THREAD_DEBUG_INFO { HANDLE hThread; LPVOID lpThreadLocalBase; LPTHREAD_START_ROUTINE lpStartAddress; } CREATE_THREAD_DEBUG_INFO, *LPCREATE_THREAD_DEBUG_INFO; typedef struct _CREATE_PROCESS_DEBUG_INFO { HANDLE hFile; HANDLE hProcess; HANDLE hThread; 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 { DWORD dwExitCode; } EXIT_THREAD_DEBUG_INFO, *LPEXIT_THREAD_DEBUG_INFO; typedef struct _EXIT_PROCESS_DEBUG_INFO { DWORD dwExitCode; } EXIT_PROCESS_DEBUG_INFO, *LPEXIT_PROCESS_DEBUG_INFO; typedef struct _LOAD_DLL_DEBUG_INFO { HANDLE hFile; LPVOID lpBaseOfDll; DWORD dwDebugInfoFileOffset; DWORD nDebugInfoSize; LPVOID lpImageName; WORD fUnicode; } LOAD_DLL_DEBUG_INFO, *LPLOAD_DLL_DEBUG_INFO; typedef struct _UNLOAD_DLL_DEBUG_INFO { LPVOID lpBaseOfDll; } UNLOAD_DLL_DEBUG_INFO, *LPUNLOAD_DLL_DEBUG_INFO; typedef struct _OUTPUT_DEBUG_STRING_INFO { LPSTR lpDebugStringData; WORD fUnicode; 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; DWORD dwThreadId; union { EXCEPTION_DEBUG_INFO Exception; CREATE_THREAD_DEBUG_INFO CreateThread; CREATE_PROCESS_DEBUG_INFO CreateProcessInfo; EXIT_THREAD_DEBUG_INFO ExitThread; EXIT_PROCESS_DEBUG_INFO ExitProcess; LOAD_DLL_DEBUG_INFO LoadDll; UNLOAD_DLL_DEBUG_INFO UnloadDll; OUTPUT_DEBUG_STRING_INFO DebugString; RIP_INFO RipInfo; } u; } DEBUG_EVENT, *LPDEBUG_EVENT; #if !defined(MIDL_PASS) typedef PCONTEXT LPCONTEXT; typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD; typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS; #endif #define DRIVE_UNKNOWN 0 #define DRIVE_NO_ROOT_DIR 1 #define DRIVE_REMOVABLE 2 #define DRIVE_FIXED 3 #define DRIVE_REMOTE 4 #define DRIVE_CDROM 5 #define DRIVE_RAMDISK 6 #ifndef _MAC #define GetFreeSpace(w) (0x100000L) #else WINBASEAPI DWORD WINAPI GetFreeSpace(UINT); #endif #define FILE_TYPE_UNKNOWN 0x0000 #define FILE_TYPE_DISK 0x0001 #define FILE_TYPE_CHAR 0x0002 #define FILE_TYPE_PIPE 0x0003 #define FILE_TYPE_REMOTE 0x8000 #define STD_INPUT_HANDLE (DWORD)-10 #define STD_OUTPUT_HANDLE (DWORD)-11 #define STD_ERROR_HANDLE (DWORD)-12 #define NOPARITY 0 #define ODDPARITY 1 #define EVENPARITY 2 #define MARKPARITY 3 #define SPACEPARITY 4 #define ONESTOPBIT 0 #define ONE5STOPBITS 1 #define TWOSTOPBITS 2 #define IGNORE 0 // Ignore signal #define INFINITE 0xFFFFFFFF // Infinite timeout // // Baud rates at which the communication device operates // #define CBR_110 110 #define CBR_300 300 #define CBR_600 600 #define CBR_1200 1200 #define CBR_2400 2400 #define CBR_4800 4800 #define CBR_9600 9600 #define CBR_14400 14400 #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 // // Error Flags // #define CE_RXOVER 0x0001 // Receive Queue overflow #define CE_OVERRUN 0x0002 // Receive Overrun Error #define CE_RXPARITY 0x0004 // Receive Parity Error #define CE_FRAME 0x0008 // Receive Framing error #define CE_BREAK 0x0010 // Break Detected #define CE_TXFULL 0x0100 // TX Queue is full #define CE_PTO 0x0200 // LPTx Timeout #define CE_IOE 0x0400 // LPTx I/O Error #define CE_DNS 0x0800 // LPTx Device not selected #define CE_OOP 0x1000 // LPTx Out-Of-Paper #define CE_MODE 0x8000 // Requested mode unsupported #define IE_BADID (-1) // Invalid or unsupported id #define IE_OPEN (-2) // Device Already Open #define IE_NOPEN (-3) // Device Not Open #define IE_MEMORY (-4) // Unable to allocate queues #define IE_DEFAULT (-5) // Error in default parameters #define IE_HARDWARE (-10) // Hardware Not Present #define IE_BYTESIZE (-11) // Illegal Byte Size #define IE_BAUDRATE (-12) // Unsupported BaudRate // // Events // #define EV_RXCHAR 0x0001 // Any Character received #define EV_RXFLAG 0x0002 // Received certain character #define EV_TXEMPTY 0x0004 // Transmitt Queue Empty #define EV_CTS 0x0008 // CTS changed state #define EV_DSR 0x0010 // DSR changed state #define EV_RLSD 0x0020 // RLSD changed state #define EV_BREAK 0x0040 // BREAK received #define EV_ERR 0x0080 // Line status error occurred #define EV_RING 0x0100 // Ring signal detected #define EV_PERR 0x0200 // Printer error occured #define EV_RX80FULL 0x0400 // Receive buffer is 80 percent full #define EV_EVENT1 0x0800 // Provider specific event 1 #define EV_EVENT2 0x1000 // Provider specific event 2 // // Escape Functions // #define SETXOFF 1 // Simulate XOFF received #define SETXON 2 // Simulate XON received #define SETRTS 3 // Set RTS high #define CLRRTS 4 // Set RTS low #define SETDTR 5 // Set DTR high #define CLRDTR 6 // Set DTR low #define RESETDEV 7 // Reset device if possible #define SETBREAK 8 // Set the device break line. #define CLRBREAK 9 // Clear the device break line. // // PURGE function flags. // #define PURGE_TXABORT 0x0001 // Kill the pending/current writes to the comm port. #define PURGE_RXABORT 0x0002 // Kill the pending/current reads to the comm port. #define PURGE_TXCLEAR 0x0004 // Kill the transmit queue if there. #define PURGE_RXCLEAR 0x0008 // Kill the typeahead buffer if there. #define LPTx 0x80 // Set if ID is for LPT device // // Modem Status Flags // #define MS_CTS_ON ((DWORD)0x0010) #define MS_DSR_ON ((DWORD)0x0020) #define MS_RING_ON ((DWORD)0x0040) #define MS_RLSD_ON ((DWORD)0x0080) // // WaitSoundState() Constants // #define S_QUEUEEMPTY 0 #define S_THRESHOLD 1 #define S_ALLTHRESHOLD 2 // // Accent Modes // #define S_NORMAL 0 #define S_LEGATO 1 #define S_STACCATO 2 // // SetSoundNoise() Sources // #define S_PERIOD512 0 // Freq = N/512 high pitch, less coarse hiss #define S_PERIOD1024 1 // Freq = N/1024 #define S_PERIOD2048 2 // Freq = N/2048 low pitch, more coarse hiss #define S_PERIODVOICE 3 // Source is frequency from voice channel (3) #define S_WHITE512 4 // Freq = N/512 high pitch, less coarse hiss #define S_WHITE1024 5 // Freq = N/1024 #define S_WHITE2048 6 // Freq = N/2048 low pitch, more coarse hiss #define S_WHITEVOICE 7 // Source is frequency from voice channel (3) #define S_SERDVNA (-1) // Device not available #define S_SEROFM (-2) // Out of memory #define S_SERMACT (-3) // Music active #define S_SERQFUL (-4) // Queue full #define S_SERBDNT (-5) // Invalid note #define S_SERDLN (-6) // Invalid note length #define S_SERDCC (-7) // Invalid note count #define S_SERDTP (-8) // Invalid tempo #define S_SERDVL (-9) // Invalid volume #define S_SERDMD (-10) // Invalid mode #define S_SERDSH (-11) // Invalid shape #define S_SERDPT (-12) // Invalid pitch #define S_SERDFQ (-13) // Invalid frequency #define S_SERDDR (-14) // Invalid duration #define S_SERDSR (-15) // Invalid source #define S_SERDST (-16) // Invalid state #define NMPWAIT_WAIT_FOREVER 0xffffffff #define NMPWAIT_NOWAIT 0x00000001 #define NMPWAIT_USE_DEFAULT_WAIT 0x00000000 #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 FS_VOL_IS_COMPRESSED FILE_VOLUME_IS_COMPRESSED #define FS_FILE_COMPRESSION FILE_FILE_COMPRESSION #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 #define OF_READ 0x00000000 #define OF_WRITE 0x00000001 #define OF_READWRITE 0x00000002 #define OF_SHARE_COMPAT 0x00000000 #define OF_SHARE_EXCLUSIVE 0x00000010 #define OF_SHARE_DENY_WRITE 0x00000020 #define OF_SHARE_DENY_READ 0x00000030 #define OF_SHARE_DENY_NONE 0x00000040 #define OF_PARSE 0x00000100 #define OF_DELETE 0x00000200 #define OF_VERIFY 0x00000400 #define OF_CANCEL 0x00000800 #define OF_CREATE 0x00001000 #define OF_PROMPT 0x00002000 #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; CHAR szPathName[OFS_MAXPATHNAME]; } OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT; // // The MS-MIPS and Alpha compilers support intrinsic functions for interlocked // increment, decrement, and exchange. // #if (defined(_M_MRX000) || defined(_M_ALPHA) || (defined(_M_PPC) && (_MSC_VER >= 1000))) && !defined(RC_INVOKED) #define InterlockedIncrement _InterlockedIncrement #define InterlockedDecrement _InterlockedDecrement #define InterlockedExchange _InterlockedExchange #define InterlockedExchangeAdd _InterlockedExchangeAdd #define InterlockedCompareExchange _InterlockedCompareExchange LONG WINAPI InterlockedIncrement( LPLONG lpAddend ); LONG WINAPI InterlockedDecrement( LPLONG lpAddend ); LONG WINAPI InterlockedExchange( LPLONG Target, LONG Value ); PVOID WINAPI InterlockedCompareExchange ( PVOID *Destination, PVOID Exchange, PVOID Comperand ); LONG WINAPI InterlockedExchangeAdd( LPLONG Addend, LONG Value ); #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) #pragma intrinsic(_InterlockedExchange) #pragma intrinsic(_InterlockedCompareExchange) #pragma intrinsic(_InterlockedExchangeAdd) #else #ifndef _NTOS_ WINBASEAPI LONG WINAPI InterlockedIncrement( LPLONG lpAddend ); WINBASEAPI LONG WINAPI InterlockedDecrement( LPLONG lpAddend ); WINBASEAPI LONG WINAPI InterlockedExchange( LPLONG Target, LONG Value ); WINBASEAPI LONG WINAPI InterlockedExchangeAdd( LPLONG Addend, LONG Value ); WINBASEAPI PVOID WINAPI InterlockedCompareExchange ( PVOID *Destination, PVOID Exchange, PVOID Comperand ); #endif /* NT_INCLUDED */ #endif WINBASEAPI BOOL WINAPI FreeResource( HGLOBAL hResData ); WINBASEAPI LPVOID WINAPI LockResource( HGLOBAL hResData ); #define UnlockResource(hResData) ((hResData), 0) #define MAXINTATOM 0xC000 #define MAKEINTATOM(i) (LPTSTR)((DWORD)((WORD)(i))) #define INVALID_ATOM ((ATOM)0) #ifndef _MAC int WINAPI #else int CALLBACK #endif WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd ); WINBASEAPI BOOL WINAPI FreeLibrary( HMODULE hLibModule ); WINBASEAPI VOID WINAPI FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode ); WINBASEAPI BOOL WINAPI DisableThreadLibraryCalls( HMODULE hLibModule ); WINBASEAPI FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR lpProcName ); WINBASEAPI DWORD WINAPI GetVersion( VOID ); WINBASEAPI HGLOBAL WINAPI GlobalAlloc( UINT uFlags, DWORD dwBytes ); WINBASEAPI HGLOBAL WINAPI GlobalReAlloc( HGLOBAL hMem, DWORD dwBytes, UINT uFlags ); WINBASEAPI DWORD WINAPI GlobalSize( HGLOBAL hMem ); WINBASEAPI UINT WINAPI GlobalFlags( HGLOBAL hMem ); WINBASEAPI LPVOID WINAPI GlobalLock( HGLOBAL hMem ); //!!!MWH My version win31 = DWORD WINAPI GlobalHandle(UINT) WINBASEAPI HGLOBAL WINAPI GlobalHandle( LPCVOID pMem ); WINBASEAPI BOOL WINAPI GlobalUnlock( HGLOBAL hMem ); WINBASEAPI HGLOBAL WINAPI GlobalFree( HGLOBAL hMem ); WINBASEAPI UINT WINAPI GlobalCompact( DWORD dwMinFree ); WINBASEAPI VOID WINAPI GlobalFix( HGLOBAL hMem ); WINBASEAPI VOID WINAPI GlobalUnfix( HGLOBAL hMem ); WINBASEAPI LPVOID WINAPI GlobalWire( HGLOBAL hMem ); WINBASEAPI BOOL WINAPI GlobalUnWire( HGLOBAL hMem ); WINBASEAPI VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ); WINBASEAPI HLOCAL WINAPI LocalAlloc( UINT uFlags, UINT uBytes ); WINBASEAPI HLOCAL WINAPI LocalReAlloc( HLOCAL hMem, UINT uBytes, UINT uFlags ); WINBASEAPI LPVOID WINAPI LocalLock( HLOCAL hMem ); WINBASEAPI HLOCAL WINAPI LocalHandle( LPCVOID pMem ); WINBASEAPI BOOL WINAPI LocalUnlock( HLOCAL hMem ); WINBASEAPI UINT WINAPI LocalSize( HLOCAL hMem ); WINBASEAPI UINT WINAPI LocalFlags( HLOCAL hMem ); WINBASEAPI HLOCAL WINAPI LocalFree( HLOCAL hMem ); WINBASEAPI UINT WINAPI LocalShrink( HLOCAL hMem, UINT cbNewSize ); WINBASEAPI UINT WINAPI LocalCompact( UINT uMinFree ); WINBASEAPI BOOL WINAPI FlushInstructionCache( HANDLE hProcess, LPCVOID lpBaseAddress, DWORD dwSize ); WINBASEAPI LPVOID WINAPI VirtualAlloc( LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect ); WINBASEAPI BOOL WINAPI VirtualFree( LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType ); WINBASEAPI BOOL WINAPI VirtualProtect( LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect ); WINBASEAPI DWORD WINAPI VirtualQuery( LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength ); WINBASEAPI LPVOID WINAPI VirtualAllocEx( HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect ); WINBASEAPI BOOL WINAPI VirtualFreeEx( HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType ); WINBASEAPI BOOL WINAPI VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect ); WINBASEAPI DWORD WINAPI VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength ); WINBASEAPI HANDLE WINAPI HeapCreate( DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize ); WINBASEAPI BOOL WINAPI HeapDestroy( HANDLE hHeap ); WINBASEAPI LPVOID WINAPI HeapAlloc( HANDLE hHeap, DWORD dwFlags, DWORD dwBytes ); WINBASEAPI LPVOID WINAPI HeapReAlloc( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, DWORD dwBytes ); WINBASEAPI BOOL WINAPI HeapFree( HANDLE hHeap, DWORD dwFlags, LPVOID lpMem ); WINBASEAPI DWORD WINAPI HeapSize( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem ); WINBASEAPI BOOL WINAPI HeapValidate( HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem ); WINBASEAPI UINT WINAPI HeapCompact( HANDLE hHeap, DWORD dwFlags ); WINBASEAPI HANDLE WINAPI GetProcessHeap( VOID ); WINBASEAPI DWORD WINAPI GetProcessHeaps( DWORD NumberOfHeaps, PHANDLE ProcessHeaps ); typedef struct _PROCESS_HEAP_ENTRY { PVOID lpData; DWORD cbData; BYTE cbOverhead; BYTE iRegionIndex; WORD wFlags; union { struct { HANDLE hMem; DWORD dwReserved[ 3 ]; } Block; struct { DWORD dwCommittedSize; DWORD dwUnCommittedSize; LPVOID lpFirstBlock; LPVOID lpLastBlock; } Region; }; } PROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY; #define PROCESS_HEAP_REGION 0x0001 #define PROCESS_HEAP_UNCOMMITTED_RANGE 0x0002 #define PROCESS_HEAP_ENTRY_BUSY 0x0004 #define PROCESS_HEAP_ENTRY_MOVEABLE 0x0010 #define PROCESS_HEAP_ENTRY_DDESHARE 0x0020 WINBASEAPI BOOL WINAPI HeapLock( HANDLE hHeap ); WINBASEAPI BOOL WINAPI HeapUnlock( HANDLE hHeap ); WINBASEAPI BOOL WINAPI HeapWalk( HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry ); // GetBinaryType return values. #define SCS_32BIT_BINARY 0 #define SCS_DOS_BINARY 1 #define SCS_WOW_BINARY 2 #define SCS_PIF_BINARY 3 #define SCS_POSIX_BINARY 4 #define SCS_OS216_BINARY 5 WINBASEAPI BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType ); WINBASEAPI BOOL WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType ); #ifdef UNICODE #define GetBinaryType GetBinaryTypeW #else #define GetBinaryType GetBinaryTypeA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetShortPathNameA( LPCSTR lpszLongPath, LPSTR lpszShortPath, DWORD cchBuffer ); WINBASEAPI DWORD WINAPI GetShortPathNameW( LPCWSTR lpszLongPath, LPWSTR lpszShortPath, DWORD cchBuffer ); #ifdef UNICODE #define GetShortPathName GetShortPathNameW #else #define GetShortPathName GetShortPathNameA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetLongPathNameA( LPCSTR lpszShortPath, LPSTR lpszLongPath, DWORD cchBuffer ); WINBASEAPI DWORD WINAPI GetLongPathNameW( LPCWSTR lpszShortPath, LPWSTR lpszLongPath, DWORD cchBuffer ); #ifdef UNICODE #define GetLongPathName GetLongPathNameW #else #define GetLongPathName GetLongPathNameA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess, LPDWORD lpProcessAffinityMask, LPDWORD lpSystemAffinityMask ); WINBASEAPI BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD dwProcessAffinityMask ); WINBASEAPI BOOL WINAPI GetProcessTimes( HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime ); WINBASEAPI BOOL WINAPI GetProcessWorkingSetSize( HANDLE hProcess, LPDWORD lpMinimumWorkingSetSize, LPDWORD lpMaximumWorkingSetSize ); WINBASEAPI BOOL WINAPI SetProcessWorkingSetSize( HANDLE hProcess, DWORD dwMinimumWorkingSetSize, DWORD dwMaximumWorkingSetSize ); WINBASEAPI HANDLE WINAPI OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId ); WINBASEAPI HANDLE WINAPI GetCurrentProcess( VOID ); WINBASEAPI DWORD WINAPI GetCurrentProcessId( VOID ); WINBASEAPI VOID WINAPI ExitProcess( UINT uExitCode ); WINBASEAPI BOOL WINAPI TerminateProcess( HANDLE hProcess, UINT uExitCode ); WINBASEAPI BOOL WINAPI GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode ); WINBASEAPI VOID WINAPI FatalExit( int ExitCode ); WINBASEAPI LPSTR WINAPI GetEnvironmentStrings( VOID ); WINBASEAPI LPWSTR WINAPI GetEnvironmentStringsW( VOID ); #ifdef UNICODE #define GetEnvironmentStrings GetEnvironmentStringsW #else #define GetEnvironmentStringsA GetEnvironmentStrings #endif // !UNICODE WINBASEAPI BOOL WINAPI FreeEnvironmentStringsA( LPSTR ); WINBASEAPI BOOL WINAPI FreeEnvironmentStringsW( LPWSTR ); #ifdef UNICODE #define FreeEnvironmentStrings FreeEnvironmentStringsW #else #define FreeEnvironmentStrings FreeEnvironmentStringsA #endif // !UNICODE WINBASEAPI VOID WINAPI RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, CONST DWORD *lpArguments ); WINBASEAPI 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; WINBASEAPI LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter ); #if(_WIN32_WINNT >= 0x0400) WINBASEAPI LPVOID WINAPI CreateFiber( DWORD dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter ); WINBASEAPI VOID WINAPI DeleteFiber( LPVOID lpFiber ); WINBASEAPI LPVOID WINAPI ConvertThreadToFiber( LPVOID lpParameter ); WINBASEAPI VOID WINAPI SwitchToFiber( LPVOID lpFiber ); WINBASEAPI BOOL WINAPI SwitchToThread( VOID ); #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI HANDLE WINAPI CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); WINBASEAPI HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); WINBASEAPI HANDLE WINAPI GetCurrentThread( VOID ); WINBASEAPI DWORD WINAPI GetCurrentThreadId( VOID ); WINBASEAPI DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask ); #if(_WIN32_WINNT >= 0x0400) WINBASEAPI DWORD WINAPI SetThreadIdealProcessor( HANDLE hThread, DWORD dwIdealProcessor ); #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI BOOL WINAPI SetProcessPriorityBoost( HANDLE hProcess, BOOL bDisablePriorityBoost ); WINBASEAPI BOOL WINAPI GetProcessPriorityBoost( HANDLE hProcess, PBOOL pDisablePriorityBoost ); WINBASEAPI BOOL WINAPI RequestWakeupLatency( LATENCY_TIME latency ); WINBASEAPI BOOL WINAPI SetThreadPriority( HANDLE hThread, int nPriority ); WINBASEAPI BOOL WINAPI SetThreadPriorityBoost( HANDLE hThread, BOOL bDisablePriorityBoost ); WINBASEAPI BOOL WINAPI GetThreadPriorityBoost( HANDLE hThread, PBOOL pDisablePriorityBoost ); WINBASEAPI int WINAPI GetThreadPriority( HANDLE hThread ); WINBASEAPI BOOL WINAPI GetThreadTimes( HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime ); WINBASEAPI VOID WINAPI ExitThread( DWORD dwExitCode ); WINBASEAPI BOOL WINAPI TerminateThread( HANDLE hThread, DWORD dwExitCode ); WINBASEAPI BOOL WINAPI GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode ); WINBASEAPI BOOL WINAPI GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry ); WINBASEAPI EXECUTION_STATE WINAPI SetThreadExecutionState( EXECUTION_STATE esFlags ); WINBASEAPI DWORD WINAPI GetLastError( VOID ); WINBASEAPI VOID WINAPI SetLastError( DWORD dwErrCode ); #define HasOverlappedIoCompleted(lpOverlapped) ((lpOverlapped)->Internal != STATUS_PENDING) WINBASEAPI BOOL WINAPI GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait ); WINBASEAPI HANDLE WINAPI CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, DWORD CompletionKey, DWORD NumberOfConcurrentThreads ); WINBASEAPI BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred, LPDWORD lpCompletionKey, LPOVERLAPPED *lpOverlapped, DWORD dwMilliseconds ); WINBASEAPI BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytesTransferred, DWORD dwCompletionKey, LPOVERLAPPED lpOverlapped ); #define SEM_FAILCRITICALERRORS 0x0001 #define SEM_NOGPFAULTERRORBOX 0x0002 #define SEM_NOALIGNMENTFAULTEXCEPT 0x0004 #define SEM_NOOPENFILEERRORBOX 0x8000 WINBASEAPI UINT WINAPI SetErrorMode( UINT uMode ); WINBASEAPI BOOL WINAPI ReadProcessMemory( HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead ); WINBASEAPI BOOL WINAPI WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesWritten ); #if !defined(MIDL_PASS) WINBASEAPI BOOL WINAPI GetThreadContext( HANDLE hThread, LPCONTEXT lpContext ); WINBASEAPI BOOL WINAPI SetThreadContext( HANDLE hThread, CONST CONTEXT *lpContext ); #endif WINBASEAPI DWORD WINAPI SuspendThread( HANDLE hThread ); WINBASEAPI DWORD WINAPI ResumeThread( HANDLE hThread ); #if(_WIN32_WINNT >= 0x0400) typedef VOID (APIENTRY *PAPCFUNC)( DWORD dwParam ); WINBASEAPI DWORD WINAPI QueueUserAPC( PAPCFUNC pfnAPC, HANDLE hThread, DWORD dwData ); #endif /* _WIN32_WINNT >= 0x0400 */ #if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400) WINBASEAPI BOOL WINAPI IsDebuggerPresent( VOID ); #endif WINBASEAPI VOID WINAPI DebugBreak( VOID ); WINBASEAPI BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds ); WINBASEAPI BOOL WINAPI ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus ); WINBASEAPI BOOL WINAPI DebugActiveProcess( DWORD dwProcessId ); WINBASEAPI VOID WINAPI InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); WINBASEAPI VOID WINAPI EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); WINBASEAPI VOID WINAPI LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); #if (_WIN32_WINNT >= 0x0500) WINBASEAPI BOOL WINAPI InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount ); WINBASEAPI DWORD WINAPI SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount ); #endif #if(_WIN32_WINNT >= 0x0400) WINBASEAPI BOOL WINAPI TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI VOID WINAPI DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); WINBASEAPI BOOL WINAPI SetEvent( HANDLE hEvent ); WINBASEAPI BOOL WINAPI ResetEvent( HANDLE hEvent ); WINBASEAPI BOOL WINAPI PulseEvent( HANDLE hEvent ); WINBASEAPI BOOL WINAPI ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount ); WINBASEAPI BOOL WINAPI ReleaseMutex( HANDLE hMutex ); WINBASEAPI DWORD WINAPI WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds ); WINBASEAPI DWORD WINAPI WaitForMultipleObjects( DWORD nCount, CONST HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds ); WINBASEAPI VOID WINAPI Sleep( DWORD dwMilliseconds ); WINBASEAPI HGLOBAL WINAPI LoadResource( HMODULE hModule, HRSRC hResInfo ); WINBASEAPI DWORD WINAPI SizeofResource( HMODULE hModule, HRSRC hResInfo ); WINBASEAPI ATOM WINAPI GlobalDeleteAtom( ATOM nAtom ); WINBASEAPI BOOL WINAPI InitAtomTable( DWORD nSize ); WINBASEAPI ATOM WINAPI DeleteAtom( ATOM nAtom ); WINBASEAPI UINT WINAPI SetHandleCount( UINT uNumber ); WINBASEAPI DWORD WINAPI GetLogicalDrives( VOID ); WINBASEAPI BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh ); WINBASEAPI BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh ); WINBASEAPI 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 WINBASEAPI 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; WINBASEAPI BOOL WINAPI GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation ); WINBASEAPI DWORD WINAPI GetFileType( HANDLE hFile ); WINBASEAPI DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh ); WINBASEAPI HANDLE WINAPI GetStdHandle( DWORD nStdHandle ); WINBASEAPI BOOL WINAPI SetStdHandle( DWORD nStdHandle, HANDLE hHandle ); WINBASEAPI BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI FlushFileBuffers( HANDLE hFile ); WINBASEAPI BOOL WINAPI DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI GetDevicePowerState( HANDLE hFile ); WINBASEAPI BOOL WINAPI SetEndOfFile( HANDLE hFile ); WINBASEAPI DWORD WINAPI SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod ); WINBASEAPI BOOL WINAPI FindClose( HANDLE hFindFile ); WINBASEAPI BOOL WINAPI GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime ); WINBASEAPI BOOL WINAPI SetFileTime( HANDLE hFile, CONST FILETIME *lpCreationTime, CONST FILETIME *lpLastAccessTime, CONST FILETIME *lpLastWriteTime ); WINBASEAPI BOOL WINAPI CloseHandle( HANDLE hObject ); WINBASEAPI BOOL WINAPI DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions ); WINBASEAPI BOOL WINAPI GetHandleInformation( HANDLE hObject, LPDWORD lpdwFlags ); WINBASEAPI BOOL WINAPI SetHandleInformation( HANDLE hObject, DWORD dwMask, DWORD dwFlags ); #define HANDLE_FLAG_INHERIT 0x00000001 #define HANDLE_FLAG_PROTECT_FROM_CLOSE 0x00000002 #define HINSTANCE_ERROR 32 WINBASEAPI DWORD WINAPI LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock ); WINBASEAPI UINT WINAPI WinExec( LPCSTR lpCmdLine, UINT uCmdShow ); WINBASEAPI BOOL WINAPI ClearCommBreak( HANDLE hFile ); WINBASEAPI BOOL WINAPI ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat ); WINBASEAPI BOOL WINAPI SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue ); WINBASEAPI BOOL WINAPI EscapeCommFunction( HANDLE hFile, DWORD dwFunc ); WINBASEAPI BOOL WINAPI GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize ); WINBASEAPI BOOL WINAPI GetCommMask( HANDLE hFile, LPDWORD lpEvtMask ); WINBASEAPI BOOL WINAPI GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp ); WINBASEAPI BOOL WINAPI GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat ); WINBASEAPI BOOL WINAPI GetCommState( HANDLE hFile, LPDCB lpDCB ); WINBASEAPI BOOL WINAPI GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); WINBASEAPI BOOL WINAPI PurgeComm( HANDLE hFile, DWORD dwFlags ); WINBASEAPI BOOL WINAPI SetCommBreak( HANDLE hFile ); WINBASEAPI BOOL WINAPI SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize ); WINBASEAPI BOOL WINAPI SetCommMask( HANDLE hFile, DWORD dwEvtMask ); WINBASEAPI BOOL WINAPI SetCommState( HANDLE hFile, LPDCB lpDCB ); WINBASEAPI BOOL WINAPI SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); WINBASEAPI BOOL WINAPI TransmitCommChar( HANDLE hFile, char cChar ); WINBASEAPI BOOL WINAPI WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped ); WINBASEAPI DWORD WINAPI SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffsetLow, DWORD dwOffsetHigh, BOOL bImmediate ); WINBASEAPI DWORD WINAPI GetTapePosition( HANDLE hDevice, DWORD dwPositionType, LPDWORD lpdwPartition, LPDWORD lpdwOffsetLow, LPDWORD lpdwOffsetHigh ); WINBASEAPI DWORD WINAPI PrepareTape( HANDLE hDevice, DWORD dwOperation, BOOL bImmediate ); WINBASEAPI DWORD WINAPI EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate ); WINBASEAPI DWORD WINAPI CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod, DWORD dwCount, DWORD dwSize ); WINBASEAPI DWORD WINAPI WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, BOOL bImmediate ); WINBASEAPI DWORD WINAPI GetTapeStatus( HANDLE hDevice ); WINBASEAPI DWORD WINAPI GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPDWORD lpdwSize, LPVOID lpTapeInformation ); #define GET_TAPE_MEDIA_INFORMATION 0 #define GET_TAPE_DRIVE_INFORMATION 1 WINBASEAPI DWORD WINAPI SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation ); #define SET_TAPE_MEDIA_INFORMATION 0 #define SET_TAPE_DRIVE_INFORMATION 1 WINBASEAPI BOOL WINAPI Beep( DWORD dwFreq, DWORD dwDuration ); WINBASEAPI int WINAPI MulDiv( int nNumber, int nNumerator, int nDenominator ); WINBASEAPI VOID WINAPI GetSystemTime( LPSYSTEMTIME lpSystemTime ); WINBASEAPI VOID WINAPI GetSystemTimeAsFileTime( LPFILETIME lpSystemTimeAsFileTime ); WINBASEAPI BOOL WINAPI SetSystemTime( CONST SYSTEMTIME *lpSystemTime ); WINBASEAPI VOID WINAPI GetLocalTime( LPSYSTEMTIME lpSystemTime ); WINBASEAPI BOOL WINAPI SetLocalTime( CONST SYSTEMTIME *lpSystemTime ); WINBASEAPI VOID WINAPI GetSystemInfo( LPSYSTEM_INFO lpSystemInfo ); WINBASEAPI BOOL WINAPI IsProcessorFeaturePresent( DWORD ProcessorFeature ); 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; WINBASEAPI BOOL WINAPI SystemTimeToTzSpecificLocalTime( LPTIME_ZONE_INFORMATION lpTimeZoneInformation, LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime ); WINBASEAPI DWORD WINAPI GetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation ); WINBASEAPI BOOL WINAPI SetTimeZoneInformation( CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation ); // // Routines to convert back and forth between system time and file time // WINBASEAPI BOOL WINAPI SystemTimeToFileTime( CONST SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime ); WINBASEAPI BOOL WINAPI FileTimeToLocalFileTime( CONST FILETIME *lpFileTime, LPFILETIME lpLocalFileTime ); WINBASEAPI BOOL WINAPI LocalFileTimeToFileTime( CONST FILETIME *lpLocalFileTime, LPFILETIME lpFileTime ); WINBASEAPI BOOL WINAPI FileTimeToSystemTime( CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime ); WINBASEAPI LONG WINAPI CompareFileTime( CONST FILETIME *lpFileTime1, CONST FILETIME *lpFileTime2 ); WINBASEAPI BOOL WINAPI FileTimeToDosDateTime( CONST FILETIME *lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime ); WINBASEAPI BOOL WINAPI DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime ); WINBASEAPI DWORD WINAPI GetTickCount( VOID ); WINBASEAPI BOOL WINAPI SetSystemTimeAdjustment( DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled ); WINBASEAPI BOOL WINAPI GetSystemTimeAdjustment( PDWORD lpTimeAdjustment, PDWORD lpTimeIncrement, PBOOL lpTimeAdjustmentDisabled ); #if !defined(MIDL_PASS) WINBASEAPI DWORD WINAPI FormatMessageA( DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list *Arguments ); WINBASEAPI 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 #endif #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 WINBASEAPI BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize ); WINBASEAPI BOOL WINAPI ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI DisconnectNamedPipe( HANDLE hNamedPipe ); WINBASEAPI BOOL WINAPI SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout ); WINBASEAPI BOOL WINAPI GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances ); WINBASEAPI BOOL WINAPI PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage ); WINBASEAPI BOOL WINAPI TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped ); WINBASEAPI HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); WINBASEAPI HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateMailslot CreateMailslotW #else #define CreateMailslot CreateMailslotA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout ); WINBASEAPI BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout ); WINBASEAPI LPVOID WINAPI MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap ); WINBASEAPI PVOID64 WINAPI MapViewOfFileVlm( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORDLONG ulOffset, DWORDLONG ulNumberOfBytesToMap, PVOID64 lpBaseAddress ); WINBASEAPI BOOL WINAPI FlushViewOfFile( LPCVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush ); WINBASEAPI BOOL WINAPI UnmapViewOfFile( LPCVOID lpBaseAddress ); WINBASEAPI BOOL WINAPI UnmapViewOfFileVlm( PVOID64 lpBaseAddress ); // // File Encryption API // WINADVAPI BOOL WINAPI EncryptFileA( LPCSTR lpFileName ); WINADVAPI BOOL WINAPI EncryptFileW( LPCWSTR lpFileName ); #ifdef UNICODE #define EncryptFile EncryptFileW #else #define EncryptFile EncryptFileA #endif // !UNICODE WINADVAPI BOOL WINAPI DecryptFileA( LPCSTR lpFileName, DWORD dwReserved ); WINADVAPI BOOL WINAPI DecryptFileW( LPCWSTR lpFileName, DWORD dwReserved ); #ifdef UNICODE #define DecryptFile DecryptFileW #else #define DecryptFile DecryptFileA #endif // !UNICODE // // Currently defined recovery flags // #define EFS_USE_RECOVERY_KEYS (0x1) typedef DWORD (*PFE_EXPORT_FUNC)( PBYTE pbData, PVOID pvCallbackContext, ULONG ulLength ); typedef DWORD (*PFE_IMPORT_FUNC)( PBYTE pbData, PVOID pvCallbackContext, PULONG ulLength ); // // OpenRaw flag values // #define CREATE_FOR_IMPORT (1) #define CREATE_FOR_DIR (2) WINADVAPI DWORD WINAPI OpenRawA( LPCSTR lpFileName, ULONG ulFlags, PVOID * pvContext ); WINADVAPI DWORD WINAPI OpenRawW( LPCWSTR lpFileName, ULONG ulFlags, PVOID * pvContext ); #ifdef UNICODE #define OpenRaw OpenRawW #else #define OpenRaw OpenRawA #endif // !UNICODE WINADVAPI DWORD WINAPI ReadRaw( PFE_EXPORT_FUNC pfExportCallback, PVOID pvCallbackContext, PVOID pvContext ); WINADVAPI DWORD WINAPI WriteRaw( PFE_IMPORT_FUNC pfImportCallback, PVOID pvCallbackContext, PVOID pvContext ); WINADVAPI VOID WINAPI CloseRaw( PVOID pvContext ); typedef struct _RECOVERY_AGENT_INFORMATIONA { DWORD NextEntryOffset; DWORD AgentNameLength; CHAR AgentInformation[1]; } RECOVERY_AGENT_INFORMATIONA, *LPRECOVERY_AGENT_INFORMATIONA; typedef struct _RECOVERY_AGENT_INFORMATIONW { DWORD NextEntryOffset; DWORD AgentNameLength; WCHAR AgentInformation[1]; } RECOVERY_AGENT_INFORMATIONW, *LPRECOVERY_AGENT_INFORMATIONW; #ifdef UNICODE typedef RECOVERY_AGENT_INFORMATIONW RECOVERY_AGENT_INFORMATION; typedef LPRECOVERY_AGENT_INFORMATIONW LPRECOVERY_AGENT_INFORMATION; #else typedef RECOVERY_AGENT_INFORMATIONA RECOVERY_AGENT_INFORMATION; typedef LPRECOVERY_AGENT_INFORMATIONA LPRECOVERY_AGENT_INFORMATION; #endif // UNICODE WINADVAPI DWORD WINAPI QueryRecoveryAgentsA( IN LPCSTR lpFileName, OUT PDWORD AgentCount, OUT LPRECOVERY_AGENT_INFORMATIONA * RecoveryAgentInformation ); WINADVAPI DWORD WINAPI QueryRecoveryAgentsW( IN LPCWSTR lpFileName, OUT PDWORD AgentCount, OUT LPRECOVERY_AGENT_INFORMATIONW * RecoveryAgentInformation ); #ifdef UNICODE #define QueryRecoveryAgents QueryRecoveryAgentsW #else #define QueryRecoveryAgents QueryRecoveryAgentsA #endif // !UNICODE // // _l Compat Functions // WINBASEAPI int WINAPI lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 ); WINBASEAPI int WINAPI lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcmp lstrcmpW #else #define lstrcmp lstrcmpA #endif // !UNICODE WINBASEAPI int WINAPI lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 ); WINBASEAPI int WINAPI lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcmpi lstrcmpiW #else #define lstrcmpi lstrcmpiA #endif // !UNICODE WINBASEAPI LPSTR WINAPI lstrcpynA( LPSTR lpString1, LPCSTR lpString2, int iMaxLength ); WINBASEAPI LPWSTR WINAPI lstrcpynW( LPWSTR lpString1, LPCWSTR lpString2, int iMaxLength ); #ifdef UNICODE #define lstrcpyn lstrcpynW #else #define lstrcpyn lstrcpynA #endif // !UNICODE WINBASEAPI LPSTR WINAPI lstrcpyA( LPSTR lpString1, LPCSTR lpString2 ); WINBASEAPI LPWSTR WINAPI lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcpy lstrcpyW #else #define lstrcpy lstrcpyA #endif // !UNICODE WINBASEAPI LPSTR WINAPI lstrcatA( LPSTR lpString1, LPCSTR lpString2 ); WINBASEAPI LPWSTR WINAPI lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcat lstrcatW #else #define lstrcat lstrcatA #endif // !UNICODE WINBASEAPI int WINAPI lstrlenA( LPCSTR lpString ); WINBASEAPI int WINAPI lstrlenW( LPCWSTR lpString ); #ifdef UNICODE #define lstrlen lstrlenW #else #define lstrlen lstrlenA #endif // !UNICODE WINBASEAPI HFILE WINAPI OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle ); WINBASEAPI HFILE WINAPI _lopen( LPCSTR lpPathName, int iReadWrite ); WINBASEAPI HFILE WINAPI _lcreat( LPCSTR lpPathName, int iAttribute ); WINBASEAPI UINT WINAPI _lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes ); WINBASEAPI UINT WINAPI _lwrite( HFILE hFile, LPCSTR lpBuffer, UINT uBytes ); WINBASEAPI long WINAPI _hread( HFILE hFile, LPVOID lpBuffer, long lBytes ); WINBASEAPI long WINAPI _hwrite( HFILE hFile, LPCSTR lpBuffer, long lBytes ); WINBASEAPI HFILE WINAPI _lclose( HFILE hFile ); WINBASEAPI LONG WINAPI _llseek( HFILE hFile, LONG lOffset, int iOrigin ); WINADVAPI BOOL WINAPI IsTextUnicode( CONST LPVOID lpBuffer, int cb, LPINT lpi ); WINBASEAPI DWORD WINAPI TlsAlloc( VOID ); #define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF WINBASEAPI LPVOID WINAPI TlsGetValue( DWORD dwTlsIndex ); WINBASEAPI BOOL WINAPI TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue ); WINBASEAPI BOOL WINAPI TlsFree( DWORD dwTlsIndex ); typedef VOID (WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)( DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped ); WINBASEAPI DWORD WINAPI SleepEx( DWORD dwMilliseconds, BOOL bAlertable ); WINBASEAPI DWORD WINAPI WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable ); WINBASEAPI DWORD WINAPI WaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable ); #if(_WIN32_WINNT >= 0x0400) WINBASEAPI DWORD WINAPI SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD dwMilliseconds, BOOL bAlertable ); #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI BOOL WINAPI ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ); WINBASEAPI BOOL WINAPI WriteFileEx( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ); WINBASEAPI BOOL WINAPI BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL bAbort, BOOL bProcessSecurity, LPVOID *lpContext ); WINBASEAPI BOOL WINAPI BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek, DWORD dwHighBytesToSeek, LPDWORD lpdwLowByteSeeked, LPDWORD lpdwHighByteSeeked, LPVOID *lpContext ); WINBASEAPI 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_INVALID 0x00000000 #define BACKUP_DATA 0x00000001 #define BACKUP_EA_DATA 0x00000002 #define BACKUP_SECURITY_DATA 0x00000003 #define BACKUP_ALTERNATE_DATA 0x00000004 #define BACKUP_LINK 0x00000005 #define BACKUP_PROPERTY_DATA 0x00000006 #define BACKUP_OBJECT_ID 0x00000007 #define BACKUP_REPARSE_DATA 0x00000008 #define BACKUP_SPARSE_BLOCK 0x00000009 // // Stream Attributes // #define STREAM_NORMAL_ATTRIBUTE 0x00000000 #define STREAM_MODIFIED_WHEN_READ 0x00000001 #define STREAM_CONTAINS_SECURITY 0x00000002 #define STREAM_CONTAINS_PROPERTIES 0x00000004 #define STREAM_SPARSE_ATTRIBUTE 0x00000008 WINBASEAPI BOOL WINAPI ReadFileScatter( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI WriteFileGather( HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped ); // // Dual Mode API below this line. Dual Mode Structures also included. // #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 #if(WINVER >= 0x0400) #define STARTF_USEHOTKEY 0x00000200 #endif /* WINVER >= 0x0400 */ typedef struct _STARTUPINFOA { DWORD cb; LPSTR lpReserved; LPSTR lpDesktop; LPSTR lpTitle; DWORD dwX; DWORD dwY; DWORD dwXSize; DWORD dwYSize; DWORD dwXCountChars; DWORD dwYCountChars; DWORD dwFillAttribute; DWORD dwFlags; WORD wShowWindow; WORD cbReserved2; LPBYTE lpReserved2; HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError; } STARTUPINFOA, *LPSTARTUPINFOA; typedef struct _STARTUPINFOW { DWORD cb; LPWSTR lpReserved; LPWSTR lpDesktop; LPWSTR lpTitle; DWORD dwX; DWORD dwY; DWORD dwXSize; DWORD dwYSize; DWORD dwXCountChars; DWORD dwYCountChars; DWORD dwFillAttribute; DWORD dwFlags; WORD wShowWindow; WORD cbReserved2; LPBYTE lpReserved2; HANDLE hStdInput; HANDLE hStdOutput; HANDLE hStdError; } STARTUPINFOW, *LPSTARTUPINFOW; #ifdef UNICODE typedef STARTUPINFOW STARTUPINFO; typedef LPSTARTUPINFOW LPSTARTUPINFO; #else typedef STARTUPINFOA STARTUPINFO; typedef LPSTARTUPINFOA LPSTARTUPINFO; #endif // UNICODE #define SHUTDOWN_NORETRY 0x00000001 typedef struct _WIN32_FIND_DATAA { DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; DWORD dwReserved0; DWORD dwReserved1; CHAR cFileName[ MAX_PATH ]; CHAR cAlternateFileName[ 14 ]; #ifdef _MAC DWORD dwFileType; DWORD dwCreatorType; WORD wFinderFlags; #endif } WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA; typedef struct _WIN32_FIND_DATAW { DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; DWORD dwReserved0; DWORD dwReserved1; WCHAR cFileName[ MAX_PATH ]; WCHAR cAlternateFileName[ 14 ]; #ifdef _MAC DWORD dwFileType; DWORD dwCreatorType; WORD wFinderFlags; #endif } WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW; #ifdef UNICODE 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 typedef struct _WIN32_FILE_ATTRIBUTE_DATA { DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD nFileSizeHigh; DWORD nFileSizeLow; } WIN32_FILE_ATTRIBUTE_DATA, *LPWIN32_FILE_ATTRIBUTE_DATA; WINBASEAPI HANDLE WINAPI CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName ); #ifdef UNICODE #define CreateMutex CreateMutexW #else #define CreateMutex CreateMutexA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName ); #ifdef UNICODE #define OpenMutex OpenMutexW #else #define OpenMutex OpenMutexA #endif // !UNICODE WINBASEAPI HANDLE WINAPI CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName ); #ifdef UNICODE #define CreateEvent CreateEventW #else #define CreateEvent CreateEventA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName ); #ifdef UNICODE #define OpenEvent OpenEventW #else #define OpenEvent OpenEventA #endif // !UNICODE WINBASEAPI HANDLE WINAPI CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName ); #ifdef UNICODE #define CreateSemaphore CreateSemaphoreW #else #define CreateSemaphore CreateSemaphoreA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName ); #ifdef UNICODE #define OpenSemaphore OpenSemaphoreW #else #define OpenSemaphore OpenSemaphoreA #endif // !UNICODE #if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400) typedef VOID (APIENTRY *PTIMERAPCROUTINE)( LPVOID lpArgToCompletionRoutine, DWORD dwTimerLowValue, DWORD dwTimerHighValue ); WINBASEAPI HANDLE WINAPI CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName ); WINBASEAPI HANDLE WINAPI CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName ); #ifdef UNICODE #define CreateWaitableTimer CreateWaitableTimerW #else #define CreateWaitableTimer CreateWaitableTimerA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenWaitableTimerA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName ); WINBASEAPI HANDLE WINAPI OpenWaitableTimerW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName ); #ifdef UNICODE #define OpenWaitableTimer OpenWaitableTimerW #else #define OpenWaitableTimer OpenWaitableTimerA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetWaitableTimer( HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume ); WINBASEAPI BOOL WINAPI CancelWaitableTimer( HANDLE hTimer ); #endif /* (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400) */ WINBASEAPI HANDLE WINAPI CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName ); #ifdef UNICODE #define CreateFileMapping CreateFileMappingW #else #define CreateFileMapping CreateFileMappingA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName ); #ifdef UNICODE #define OpenFileMapping OpenFileMappingW #else #define OpenFileMapping OpenFileMappingA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer ); WINBASEAPI DWORD WINAPI GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetLogicalDriveStrings GetLogicalDriveStringsW #else #define GetLogicalDriveStrings GetLogicalDriveStringsA #endif // !UNICODE WINBASEAPI HMODULE WINAPI LoadLibraryA( LPCSTR lpLibFileName ); WINBASEAPI HMODULE WINAPI LoadLibraryW( LPCWSTR lpLibFileName ); #ifdef UNICODE #define LoadLibrary LoadLibraryW #else #define LoadLibrary LoadLibraryA #endif // !UNICODE WINBASEAPI HMODULE WINAPI LoadLibraryExA( LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags ); WINBASEAPI HMODULE WINAPI LoadLibraryExW( LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags ); #ifdef UNICODE #define LoadLibraryEx LoadLibraryExW #else #define LoadLibraryEx LoadLibraryExA #endif // !UNICODE #define DONT_RESOLVE_DLL_REFERENCES 0x00000001 #define LOAD_LIBRARY_AS_DATAFILE 0x00000002 #define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008 WINBASEAPI DWORD WINAPI GetModuleFileNameA( HMODULE hModule, LPSTR lpFilename, DWORD nSize ); WINBASEAPI DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFilename, DWORD nSize ); #ifdef UNICODE #define GetModuleFileName GetModuleFileNameW #else #define GetModuleFileName GetModuleFileNameA #endif // !UNICODE WINBASEAPI HMODULE WINAPI GetModuleHandleA( LPCSTR lpModuleName ); WINBASEAPI HMODULE WINAPI GetModuleHandleW( LPCWSTR lpModuleName ); #ifdef UNICODE #define GetModuleHandle GetModuleHandleW #else #define GetModuleHandle GetModuleHandleA #endif // !UNICODE WINBASEAPI BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); WINBASEAPI BOOL WINAPI CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); #ifdef UNICODE #define CreateProcess CreateProcessW #else #define CreateProcess CreateProcessA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetProcessShutdownParameters( DWORD dwLevel, DWORD dwFlags ); WINBASEAPI BOOL WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags ); WINBASEAPI DWORD WINAPI GetProcessVersion( DWORD ProcessId ); WINBASEAPI VOID WINAPI FatalAppExitA( UINT uAction, LPCSTR lpMessageText ); WINBASEAPI VOID WINAPI FatalAppExitW( UINT uAction, LPCWSTR lpMessageText ); #ifdef UNICODE #define FatalAppExit FatalAppExitW #else #define FatalAppExit FatalAppExitA #endif // !UNICODE WINBASEAPI VOID WINAPI GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo ); WINBASEAPI VOID WINAPI GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo ); #ifdef UNICODE #define GetStartupInfo GetStartupInfoW #else #define GetStartupInfo GetStartupInfoA #endif // !UNICODE WINBASEAPI LPSTR WINAPI GetCommandLineA( VOID ); WINBASEAPI LPWSTR WINAPI GetCommandLineW( VOID ); #ifdef UNICODE #define GetCommandLine GetCommandLineW #else #define GetCommandLine GetCommandLineA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize ); WINBASEAPI DWORD WINAPI GetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize ); #ifdef UNICODE #define GetEnvironmentVariable GetEnvironmentVariableW #else #define GetEnvironmentVariable GetEnvironmentVariableA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetEnvironmentVariableA( LPCSTR lpName, LPCSTR lpValue ); WINBASEAPI BOOL WINAPI SetEnvironmentVariableW( LPCWSTR lpName, LPCWSTR lpValue ); #ifdef UNICODE #define SetEnvironmentVariable SetEnvironmentVariableW #else #define SetEnvironmentVariable SetEnvironmentVariableA #endif // !UNICODE WINBASEAPI DWORD WINAPI ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize ); WINBASEAPI DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize ); #ifdef UNICODE #define ExpandEnvironmentStrings ExpandEnvironmentStringsW #else #define ExpandEnvironmentStrings ExpandEnvironmentStringsA #endif // !UNICODE WINBASEAPI VOID WINAPI OutputDebugStringA( LPCSTR lpOutputString ); WINBASEAPI VOID WINAPI OutputDebugStringW( LPCWSTR lpOutputString ); #ifdef UNICODE #define OutputDebugString OutputDebugStringW #else #define OutputDebugString OutputDebugStringA #endif // !UNICODE WINBASEAPI HRSRC WINAPI FindResourceA( HMODULE hModule, LPCSTR lpName, LPCSTR lpType ); WINBASEAPI HRSRC WINAPI FindResourceW( HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType ); #ifdef UNICODE #define FindResource FindResourceW #else #define FindResource FindResourceA #endif // !UNICODE WINBASEAPI HRSRC WINAPI FindResourceExA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage ); WINBASEAPI HRSRC WINAPI FindResourceExW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage ); #ifdef UNICODE #define FindResourceEx FindResourceExW #else #define FindResourceEx FindResourceExA #endif // !UNICODE #ifdef STRICT typedef BOOL (CALLBACK* ENUMRESTYPEPROC)(HMODULE hModule, LPTSTR lpType, LONG lParam); typedef BOOL (CALLBACK* ENUMRESNAMEPROC)(HMODULE hModule, LPCTSTR lpType, LPTSTR lpName, LONG lParam); typedef BOOL (CALLBACK* ENUMRESLANGPROC)(HMODULE hModule, LPCTSTR lpType, LPCTSTR lpName, WORD wLanguage, LONG lParam); #else typedef FARPROC ENUMRESTYPEPROC; typedef FARPROC ENUMRESNAMEPROC; typedef FARPROC ENUMRESLANGPROC; #endif WINBASEAPI BOOL WINAPI EnumResourceTypesA( HMODULE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); WINBASEAPI BOOL WINAPI EnumResourceTypesW( HMODULE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceTypes EnumResourceTypesW #else #define EnumResourceTypes EnumResourceTypesA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumResourceNamesA( HMODULE hModule, LPCSTR lpType, ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); WINBASEAPI BOOL WINAPI EnumResourceNamesW( HMODULE hModule, LPCWSTR lpType, ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceNames EnumResourceNamesW #else #define EnumResourceNames EnumResourceNamesA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumResourceLanguagesA( HMODULE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROC lpEnumFunc, LONG lParam ); WINBASEAPI BOOL WINAPI EnumResourceLanguagesW( HMODULE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceLanguages EnumResourceLanguagesW #else #define EnumResourceLanguages EnumResourceLanguagesA #endif // !UNICODE WINBASEAPI HANDLE WINAPI BeginUpdateResourceA( LPCSTR pFileName, BOOL bDeleteExistingResources ); WINBASEAPI HANDLE WINAPI BeginUpdateResourceW( LPCWSTR pFileName, BOOL bDeleteExistingResources ); #ifdef UNICODE #define BeginUpdateResource BeginUpdateResourceW #else #define BeginUpdateResource BeginUpdateResourceA #endif // !UNICODE WINBASEAPI BOOL WINAPI UpdateResourceA( HANDLE hUpdate, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData ); WINBASEAPI BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData ); #ifdef UNICODE #define UpdateResource UpdateResourceW #else #define UpdateResource UpdateResourceA #endif // !UNICODE WINBASEAPI BOOL WINAPI EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard ); WINBASEAPI BOOL WINAPI EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard ); #ifdef UNICODE #define EndUpdateResource EndUpdateResourceW #else #define EndUpdateResource EndUpdateResourceA #endif // !UNICODE WINBASEAPI ATOM WINAPI GlobalAddAtomA( LPCSTR lpString ); WINBASEAPI ATOM WINAPI GlobalAddAtomW( LPCWSTR lpString ); #ifdef UNICODE #define GlobalAddAtom GlobalAddAtomW #else #define GlobalAddAtom GlobalAddAtomA #endif // !UNICODE WINBASEAPI ATOM WINAPI GlobalFindAtomA( LPCSTR lpString ); WINBASEAPI ATOM WINAPI GlobalFindAtomW( LPCWSTR lpString ); #ifdef UNICODE #define GlobalFindAtom GlobalFindAtomW #else #define GlobalFindAtom GlobalFindAtomA #endif // !UNICODE WINBASEAPI UINT WINAPI GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize ); WINBASEAPI UINT WINAPI GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize ); #ifdef UNICODE #define GlobalGetAtomName GlobalGetAtomNameW #else #define GlobalGetAtomName GlobalGetAtomNameA #endif // !UNICODE WINBASEAPI ATOM WINAPI AddAtomA( LPCSTR lpString ); WINBASEAPI ATOM WINAPI AddAtomW( LPCWSTR lpString ); #ifdef UNICODE #define AddAtom AddAtomW #else #define AddAtom AddAtomA #endif // !UNICODE WINBASEAPI ATOM WINAPI FindAtomA( LPCSTR lpString ); WINBASEAPI ATOM WINAPI FindAtomW( LPCWSTR lpString ); #ifdef UNICODE #define FindAtom FindAtomW #else #define FindAtom FindAtomA #endif // !UNICODE WINBASEAPI UINT WINAPI GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize ); WINBASEAPI UINT WINAPI GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize ); #ifdef UNICODE #define GetAtomName GetAtomNameW #else #define GetAtomName GetAtomNameA #endif // !UNICODE WINBASEAPI UINT WINAPI GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault ); WINBASEAPI UINT WINAPI GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault ); #ifdef UNICODE #define GetProfileInt GetProfileIntW #else #define GetProfileInt GetProfileIntA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize ); WINBASEAPI DWORD WINAPI GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE #define GetProfileString GetProfileStringW #else #define GetProfileString GetProfileStringA #endif // !UNICODE WINBASEAPI BOOL WINAPI WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString ); WINBASEAPI BOOL WINAPI WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString ); #ifdef UNICODE #define WriteProfileString WriteProfileStringW #else #define WriteProfileString WriteProfileStringA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize ); WINBASEAPI DWORD WINAPI GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE #define GetProfileSection GetProfileSectionW #else #define GetProfileSection GetProfileSectionA #endif // !UNICODE WINBASEAPI BOOL WINAPI WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString ); WINBASEAPI BOOL WINAPI WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString ); #ifdef UNICODE #define WriteProfileSection WriteProfileSectionW #else #define WriteProfileSection WriteProfileSectionA #endif // !UNICODE WINBASEAPI UINT WINAPI GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, INT nDefault, LPCSTR lpFileName ); WINBASEAPI UINT WINAPI GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, INT nDefault, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileInt GetPrivateProfileIntW #else #define GetPrivateProfileInt GetPrivateProfileIntA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName ); WINBASEAPI DWORD WINAPI GetPrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileString GetPrivateProfileStringW #else #define GetPrivateProfileString GetPrivateProfileStringA #endif // !UNICODE WINBASEAPI BOOL WINAPI WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName ); WINBASEAPI BOOL WINAPI WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName ); #ifdef UNICODE #define WritePrivateProfileString WritePrivateProfileStringW #else #define WritePrivateProfileString WritePrivateProfileStringA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName ); WINBASEAPI DWORD WINAPI GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileSection GetPrivateProfileSectionW #else #define GetPrivateProfileSection GetPrivateProfileSectionA #endif // !UNICODE WINBASEAPI BOOL WINAPI WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName ); WINBASEAPI BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName ); #ifdef UNICODE #define WritePrivateProfileSection WritePrivateProfileSectionW #else #define WritePrivateProfileSection WritePrivateProfileSectionA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetPrivateProfileSectionNamesA( LPSTR lpszReturnBuffer, DWORD nSize, LPCSTR lpFileName ); WINBASEAPI DWORD WINAPI GetPrivateProfileSectionNamesW( LPWSTR lpszReturnBuffer, DWORD nSize, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesW #else #define GetPrivateProfileSectionNames GetPrivateProfileSectionNamesA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetPrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile ); WINBASEAPI BOOL WINAPI GetPrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile ); #ifdef UNICODE #define GetPrivateProfileStruct GetPrivateProfileStructW #else #define GetPrivateProfileStruct GetPrivateProfileStructA #endif // !UNICODE WINBASEAPI BOOL WINAPI WritePrivateProfileStructA( LPCSTR lpszSection, LPCSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCSTR szFile ); WINBASEAPI BOOL WINAPI WritePrivateProfileStructW( LPCWSTR lpszSection, LPCWSTR lpszKey, LPVOID lpStruct, UINT uSizeStruct, LPCWSTR szFile ); #ifdef UNICODE #define WritePrivateProfileStruct WritePrivateProfileStructW #else #define WritePrivateProfileStruct WritePrivateProfileStructA #endif // !UNICODE WINBASEAPI UINT WINAPI GetDriveTypeA( LPCSTR lpRootPathName ); WINBASEAPI UINT WINAPI GetDriveTypeW( LPCWSTR lpRootPathName ); #ifdef UNICODE #define GetDriveType GetDriveTypeW #else #define GetDriveType GetDriveTypeA #endif // !UNICODE WINBASEAPI UINT WINAPI GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize ); WINBASEAPI UINT WINAPI GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize ); #ifdef UNICODE #define GetSystemDirectory GetSystemDirectoryW #else #define GetSystemDirectory GetSystemDirectoryA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer ); WINBASEAPI DWORD WINAPI GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetTempPath GetTempPathW #else #define GetTempPath GetTempPathA #endif // !UNICODE WINBASEAPI UINT WINAPI GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName ); WINBASEAPI UINT WINAPI GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName ); #ifdef UNICODE #define GetTempFileName GetTempFileNameW #else #define GetTempFileName GetTempFileNameA #endif // !UNICODE WINBASEAPI UINT WINAPI GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize ); WINBASEAPI UINT WINAPI GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize ); #ifdef UNICODE #define GetWindowsDirectory GetWindowsDirectoryW #else #define GetWindowsDirectory GetWindowsDirectoryA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetCurrentDirectoryA( LPCSTR lpPathName ); WINBASEAPI BOOL WINAPI SetCurrentDirectoryW( LPCWSTR lpPathName ); #ifdef UNICODE #define SetCurrentDirectory SetCurrentDirectoryW #else #define SetCurrentDirectory SetCurrentDirectoryA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer ); WINBASEAPI DWORD WINAPI GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetCurrentDirectory GetCurrentDirectoryW #else #define GetCurrentDirectory GetCurrentDirectoryA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetDiskFreeSpaceA( LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); WINBASEAPI BOOL WINAPI GetDiskFreeSpaceW( LPCWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); #ifdef UNICODE #define GetDiskFreeSpace GetDiskFreeSpaceW #else #define GetDiskFreeSpace GetDiskFreeSpaceA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes ); WINBASEAPI BOOL WINAPI GetDiskFreeSpaceExW( LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailableToCaller, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes ); #ifdef UNICODE #define GetDiskFreeSpaceEx GetDiskFreeSpaceExW #else #define GetDiskFreeSpaceEx GetDiskFreeSpaceExA #endif // !UNICODE WINBASEAPI BOOL WINAPI CreateDirectoryA( LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); WINBASEAPI BOOL WINAPI CreateDirectoryW( LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateDirectory CreateDirectoryW #else #define CreateDirectory CreateDirectoryA #endif // !UNICODE WINBASEAPI BOOL WINAPI CreateDirectoryExA( LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); WINBASEAPI BOOL WINAPI CreateDirectoryExW( LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateDirectoryEx CreateDirectoryExW #else #define CreateDirectoryEx CreateDirectoryExA #endif // !UNICODE WINBASEAPI BOOL WINAPI RemoveDirectoryA( LPCSTR lpPathName ); WINBASEAPI BOOL WINAPI RemoveDirectoryW( LPCWSTR lpPathName ); #ifdef UNICODE #define RemoveDirectory RemoveDirectoryW #else #define RemoveDirectory RemoveDirectoryA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); WINBASEAPI DWORD WINAPI GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart ); #ifdef UNICODE #define GetFullPathName GetFullPathNameW #else #define GetFullPathName GetFullPathNameA #endif // !UNICODE #define DDD_RAW_TARGET_PATH 0x00000001 #define DDD_REMOVE_DEFINITION 0x00000002 #define DDD_EXACT_MATCH_ON_REMOVE 0x00000004 #define DDD_NO_BROADCAST_SYSTEM 0x00000008 WINBASEAPI BOOL WINAPI DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName, LPCSTR lpTargetPath ); WINBASEAPI BOOL WINAPI DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName, LPCWSTR lpTargetPath ); #ifdef UNICODE #define DefineDosDevice DefineDosDeviceW #else #define DefineDosDevice DefineDosDeviceA #endif // !UNICODE WINBASEAPI DWORD WINAPI QueryDosDeviceA( LPCSTR lpDeviceName, LPSTR lpTargetPath, DWORD ucchMax ); WINBASEAPI DWORD WINAPI QueryDosDeviceW( LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax ); #ifdef UNICODE #define QueryDosDevice QueryDosDeviceW #else #define QueryDosDevice QueryDosDeviceA #endif // !UNICODE #define EXPAND_LOCAL_DRIVES WINBASEAPI HANDLE WINAPI CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ); WINBASEAPI HANDLE WINAPI CreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ); #ifdef UNICODE #define CreateFile CreateFileW #else #define CreateFile CreateFileA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetFileAttributesA( LPCSTR lpFileName, DWORD dwFileAttributes ); WINBASEAPI BOOL WINAPI SetFileAttributesW( LPCWSTR lpFileName, DWORD dwFileAttributes ); #ifdef UNICODE #define SetFileAttributes SetFileAttributesW #else #define SetFileAttributes SetFileAttributesA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetFileAttributesA( LPCSTR lpFileName ); WINBASEAPI DWORD WINAPI GetFileAttributesW( LPCWSTR lpFileName ); #ifdef UNICODE #define GetFileAttributes GetFileAttributesW #else #define GetFileAttributes GetFileAttributesA #endif // !UNICODE typedef enum _GET_FILEEX_INFO_LEVELS { GetFileExInfoStandard, GetFileExMaxInfoLevel } GET_FILEEX_INFO_LEVELS; WINBASEAPI BOOL WINAPI GetFileAttributesExA( LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation ); WINBASEAPI BOOL WINAPI GetFileAttributesExW( LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation ); #ifdef UNICODE #define GetFileAttributesEx GetFileAttributesExW #else #define GetFileAttributesEx GetFileAttributesExA #endif // !UNICODE WINBASEAPI DWORD WINAPI GetCompressedFileSizeA( LPCSTR lpFileName, LPDWORD lpFileSizeHigh ); WINBASEAPI DWORD WINAPI GetCompressedFileSizeW( LPCWSTR lpFileName, LPDWORD lpFileSizeHigh ); #ifdef UNICODE #define GetCompressedFileSize GetCompressedFileSizeW #else #define GetCompressedFileSize GetCompressedFileSizeA #endif // !UNICODE WINBASEAPI BOOL WINAPI DeleteFileA( LPCSTR lpFileName ); WINBASEAPI BOOL WINAPI DeleteFileW( LPCWSTR lpFileName ); #ifdef UNICODE #define DeleteFile DeleteFileW #else #define DeleteFile DeleteFileA #endif // !UNICODE #if(_WIN32_WINNT >= 0x0400) typedef enum _FINDEX_INFO_LEVELS { FindExInfoStandard, FindExInfoMaxInfoLevel } FINDEX_INFO_LEVELS; typedef enum _FINDEX_SEARCH_OPS { FindExSearchNameMatch, FindExSearchLimitToDirectories, FindExSearchLimitToDevices, FindExSearchMaxSearchOp } FINDEX_SEARCH_OPS; #define FIND_FIRST_EX_CASE_SENSITIVE 0x00000001 WINBASEAPI HANDLE WINAPI FindFirstFileExA( LPCSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags ); WINBASEAPI HANDLE WINAPI FindFirstFileExW( LPCWSTR lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, LPVOID lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, LPVOID lpSearchFilter, DWORD dwAdditionalFlags ); #ifdef UNICODE #define FindFirstFileEx FindFirstFileExW #else #define FindFirstFileEx FindFirstFileExA #endif // !UNICODE #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI HANDLE WINAPI FindFirstFileA( LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData ); WINBASEAPI HANDLE WINAPI FindFirstFileW( LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE #define FindFirstFile FindFirstFileW #else #define FindFirstFile FindFirstFileA #endif // !UNICODE WINBASEAPI BOOL WINAPI FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData ); WINBASEAPI BOOL WINAPI FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE #define FindNextFile FindNextFileW #else #define FindNextFile FindNextFileA #endif // !UNICODE WINBASEAPI DWORD WINAPI SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); WINBASEAPI DWORD WINAPI SearchPathW( LPCWSTR lpPath, LPCWSTR lpFileName, LPCWSTR lpExtension, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart ); #ifdef UNICODE #define SearchPath SearchPathW #else #define SearchPath SearchPathA #endif // !UNICODE WINBASEAPI BOOL WINAPI CopyFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists ); WINBASEAPI BOOL WINAPI CopyFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists ); #ifdef UNICODE #define CopyFile CopyFileW #else #define CopyFile CopyFileA #endif // !UNICODE #if(_WIN32_WINNT >= 0x0400) typedef DWORD (WINAPI *LPPROGRESS_ROUTINE)( LARGE_INTEGER TotalFileSize, LARGE_INTEGER TotalBytesTransferred, LARGE_INTEGER StreamSize, LARGE_INTEGER StreamBytesTransferred, DWORD dwStreamNumber, DWORD dwCallbackReason, HANDLE hSourceFile, HANDLE hDestinationFile, LPVOID lpData OPTIONAL ); WINBASEAPI BOOL WINAPI CopyFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, LPVOID lpData OPTIONAL, LPBOOL pbCancel OPTIONAL, DWORD dwCopyFlags ); WINBASEAPI BOOL WINAPI CopyFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, LPVOID lpData OPTIONAL, LPBOOL pbCancel OPTIONAL, DWORD dwCopyFlags ); #ifdef UNICODE #define CopyFileEx CopyFileExW #else #define CopyFileEx CopyFileExA #endif // !UNICODE #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI BOOL WINAPI MoveFileA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName ); WINBASEAPI BOOL WINAPI MoveFileW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName ); #ifdef UNICODE #define MoveFile MoveFileW #else #define MoveFile MoveFileA #endif // !UNICODE WINBASEAPI BOOL WINAPI MoveFileExA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags ); WINBASEAPI BOOL WINAPI MoveFileExW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, DWORD dwFlags ); #ifdef UNICODE #define MoveFileEx MoveFileExW #else #define MoveFileEx MoveFileExA #endif // !UNICODE #if (_WIN32_WINNT >= 0x0500) WINBASEAPI BOOL WINAPI MoveFileWithProgressA( LPCSTR lpExistingFileName, LPCSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, LPVOID lpData OPTIONAL, DWORD dwFlags ); WINBASEAPI BOOL WINAPI MoveFileWithProgressW( LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, LPVOID lpData OPTIONAL, DWORD dwFlags ); #ifdef UNICODE #define MoveFileWithProgress MoveFileWithProgressW #else #define MoveFileWithProgress MoveFileWithProgressA #endif // !UNICODE #endif // (_WIN32_WINNT >= 0x0500) #define MOVEFILE_REPLACE_EXISTING 0x00000001 #define MOVEFILE_COPY_ALLOWED 0x00000002 #define MOVEFILE_DELAY_UNTIL_REBOOT 0x00000004 #define MOVEFILE_WRITE_THROUGH 0x00000008 #if (_WIN32_WINNT >= 0x0500) #define MOVEFILE_CREATE_HARDLINK 0x00000010 #define MOVEFILE_FAIL_IF_NOT_TRACKABLE 0x00000020 #endif // (_WIN32_WINNT >= 0x0500) #if (_WIN32_WINNT >= 0x0500) // // API call to create hard links. // WINBASEAPI BOOL WINAPI CreateHardLinkA( LPCSTR lpFileName, LPCSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); WINBASEAPI BOOL WINAPI CreateHardLinkW( LPCWSTR lpFileName, LPCWSTR lpExistingFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateHardLink CreateHardLinkW #else #define CreateHardLink CreateHardLinkA #endif // !UNICODE #endif // (_WIN32_WINNT >= 0x0500) WINBASEAPI HANDLE WINAPI CreateNamedPipeA( LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); WINBASEAPI HANDLE WINAPI CreateNamedPipeW( LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateNamedPipe CreateNamedPipeW #else #define CreateNamedPipe CreateNamedPipeA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize ); WINBASEAPI BOOL WINAPI GetNamedPipeHandleStateW( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPWSTR lpUserName, DWORD nMaxUserNameSize ); #ifdef UNICODE #define GetNamedPipeHandleState GetNamedPipeHandleStateW #else #define GetNamedPipeHandleState GetNamedPipeHandleStateA #endif // !UNICODE WINBASEAPI BOOL WINAPI CallNamedPipeA( LPCSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut ); WINBASEAPI BOOL WINAPI CallNamedPipeW( LPCWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut ); #ifdef UNICODE #define CallNamedPipe CallNamedPipeW #else #define CallNamedPipe CallNamedPipeA #endif // !UNICODE WINBASEAPI BOOL WINAPI WaitNamedPipeA( LPCSTR lpNamedPipeName, DWORD nTimeOut ); WINBASEAPI BOOL WINAPI WaitNamedPipeW( LPCWSTR lpNamedPipeName, DWORD nTimeOut ); #ifdef UNICODE #define WaitNamedPipe WaitNamedPipeW #else #define WaitNamedPipe WaitNamedPipeA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetVolumeLabelA( LPCSTR lpRootPathName, LPCSTR lpVolumeName ); WINBASEAPI BOOL WINAPI SetVolumeLabelW( LPCWSTR lpRootPathName, LPCWSTR lpVolumeName ); #ifdef UNICODE #define SetVolumeLabel SetVolumeLabelW #else #define SetVolumeLabel SetVolumeLabelA #endif // !UNICODE WINBASEAPI VOID WINAPI SetFileApisToOEM( VOID ); WINBASEAPI VOID WINAPI SetFileApisToANSI( VOID ); WINBASEAPI BOOL WINAPI AreFileApisANSI( VOID ); WINBASEAPI BOOL WINAPI GetVolumeInformationA( LPCSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize ); WINBASEAPI BOOL WINAPI GetVolumeInformationW( LPCWSTR lpRootPathName, LPWSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPWSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize ); #ifdef UNICODE #define GetVolumeInformation GetVolumeInformationW #else #define GetVolumeInformation GetVolumeInformationA #endif // !UNICODE WINBASEAPI BOOL WINAPI CancelIo( HANDLE hFile ); // // Event logging APIs // WINADVAPI BOOL WINAPI ClearEventLogA ( HANDLE hEventLog, LPCSTR lpBackupFileName ); WINADVAPI BOOL WINAPI ClearEventLogW ( HANDLE hEventLog, LPCWSTR lpBackupFileName ); #ifdef UNICODE #define ClearEventLog ClearEventLogW #else #define ClearEventLog ClearEventLogA #endif // !UNICODE WINADVAPI BOOL WINAPI BackupEventLogA ( HANDLE hEventLog, LPCSTR lpBackupFileName ); WINADVAPI BOOL WINAPI BackupEventLogW ( HANDLE hEventLog, LPCWSTR lpBackupFileName ); #ifdef UNICODE #define BackupEventLog BackupEventLogW #else #define BackupEventLog BackupEventLogA #endif // !UNICODE WINADVAPI BOOL WINAPI CloseEventLog ( HANDLE hEventLog ); WINADVAPI BOOL WINAPI DeregisterEventSource ( HANDLE hEventLog ); WINADVAPI BOOL WINAPI NotifyChangeEventLog( HANDLE hEventLog, HANDLE hEvent ); WINADVAPI BOOL WINAPI GetNumberOfEventLogRecords ( HANDLE hEventLog, PDWORD NumberOfRecords ); WINADVAPI BOOL WINAPI GetOldestEventLogRecord ( HANDLE hEventLog, PDWORD OldestRecord ); WINADVAPI HANDLE WINAPI OpenEventLogA ( LPCSTR lpUNCServerName, LPCSTR lpSourceName ); WINADVAPI HANDLE WINAPI OpenEventLogW ( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName ); #ifdef UNICODE #define OpenEventLog OpenEventLogW #else #define OpenEventLog OpenEventLogA #endif // !UNICODE WINADVAPI HANDLE WINAPI RegisterEventSourceA ( LPCSTR lpUNCServerName, LPCSTR lpSourceName ); WINADVAPI HANDLE WINAPI RegisterEventSourceW ( LPCWSTR lpUNCServerName, LPCWSTR lpSourceName ); #ifdef UNICODE #define RegisterEventSource RegisterEventSourceW #else #define RegisterEventSource RegisterEventSourceA #endif // !UNICODE WINADVAPI HANDLE WINAPI OpenBackupEventLogA ( LPCSTR lpUNCServerName, LPCSTR lpFileName ); WINADVAPI HANDLE WINAPI OpenBackupEventLogW ( LPCWSTR lpUNCServerName, LPCWSTR lpFileName ); #ifdef UNICODE #define OpenBackupEventLog OpenBackupEventLogW #else #define OpenBackupEventLog OpenBackupEventLogA #endif // !UNICODE WINADVAPI BOOL WINAPI ReadEventLogA ( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded ); WINADVAPI BOOL WINAPI ReadEventLogW ( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded ); #ifdef UNICODE #define ReadEventLog ReadEventLogW #else #define ReadEventLog ReadEventLogA #endif // !UNICODE WINADVAPI BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCSTR *lpStrings, LPVOID lpRawData ); WINADVAPI 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 // WINADVAPI BOOL WINAPI DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle ); WINADVAPI BOOL WINAPI GetKernelObjectSecurity ( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); WINADVAPI BOOL WINAPI ImpersonateNamedPipeClient( HANDLE hNamedPipe ); WINADVAPI BOOL WINAPI ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel ); WINADVAPI BOOL WINAPI RevertToSelf ( VOID ); WINADVAPI BOOL APIENTRY SetThreadToken ( PHANDLE Thread, HANDLE Token ); WINADVAPI BOOL WINAPI AccessCheck ( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI AccessCheckByType ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus ); WINADVAPI BOOL WINAPI AccessCheckByTypeResultList ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID PrincipalSelfSid, HANDLE ClientToken, DWORD DesiredAccess, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccessList, LPDWORD AccessStatusList ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI OpenProcessToken ( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle ); WINADVAPI BOOL WINAPI OpenThreadToken ( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle ); WINADVAPI BOOL WINAPI GetTokenInformation ( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength ); WINADVAPI BOOL WINAPI SetTokenInformation ( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength ); WINADVAPI BOOL WINAPI AdjustTokenPrivileges ( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength ); WINADVAPI BOOL WINAPI AdjustTokenGroups ( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength ); WINADVAPI BOOL WINAPI PrivilegeCheck ( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult ); WINADVAPI 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 ); WINADVAPI 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 #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI AccessCheckByTypeAndAuditAlarmA ( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose ); WINADVAPI BOOL WINAPI AccessCheckByTypeAndAuditAlarmW ( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose ); #ifdef UNICODE #define AccessCheckByTypeAndAuditAlarm AccessCheckByTypeAndAuditAlarmW #else #define AccessCheckByTypeAndAuditAlarm AccessCheckByTypeAndAuditAlarmA #endif // !UNICODE WINADVAPI BOOL WINAPI AccessCheckByTypeResultListAndAuditAlarmA ( LPCSTR SubsystemName, LPVOID HandleId, LPCSTR ObjectTypeName, LPCSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose ); WINADVAPI BOOL WINAPI AccessCheckByTypeResultListAndAuditAlarmW ( LPCWSTR SubsystemName, LPVOID HandleId, LPCWSTR ObjectTypeName, LPCWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, PSID PrincipalSelfSid, DWORD DesiredAccess, AUDIT_EVENT_TYPE AuditType, DWORD Flags, POBJECT_TYPE_LIST ObjectTypeList, DWORD ObjectTypeListLength, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPDWORD AccessStatusList, LPBOOL pfGenerateOnClose ); #ifdef UNICODE #define AccessCheckByTypeResultListAndAuditAlarm AccessCheckByTypeResultListAndAuditAlarmW #else #define AccessCheckByTypeResultListAndAuditAlarm AccessCheckByTypeResultListAndAuditAlarmA #endif // !UNICODE #endif //(_WIN32_WINNT >= 0x0500) WINADVAPI 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 ); WINADVAPI 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 WINADVAPI BOOL WINAPI ObjectPrivilegeAuditAlarmA ( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); WINADVAPI 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 WINADVAPI BOOL WINAPI ObjectCloseAuditAlarmA ( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); WINADVAPI BOOL WINAPI ObjectCloseAuditAlarmW ( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); #ifdef UNICODE #define ObjectCloseAuditAlarm ObjectCloseAuditAlarmW #else #define ObjectCloseAuditAlarm ObjectCloseAuditAlarmA #endif // !UNICODE WINADVAPI BOOL WINAPI ObjectDeleteAuditAlarmA ( LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); WINADVAPI BOOL WINAPI ObjectDeleteAuditAlarmW ( LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); #ifdef UNICODE #define ObjectDeleteAuditAlarm ObjectDeleteAuditAlarmW #else #define ObjectDeleteAuditAlarm ObjectDeleteAuditAlarmA #endif // !UNICODE WINADVAPI BOOL WINAPI PrivilegedServiceAuditAlarmA ( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); WINADVAPI 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 WINADVAPI BOOL WINAPI IsValidSid ( PSID pSid ); WINADVAPI BOOL WINAPI EqualSid ( PSID pSid1, PSID pSid2 ); WINADVAPI BOOL WINAPI EqualPrefixSid ( PSID pSid1, PSID pSid2 ); WINADVAPI DWORD WINAPI GetSidLengthRequired ( UCHAR nSubAuthorityCount ); WINADVAPI 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 ); WINADVAPI PVOID WINAPI FreeSid( PSID pSid ); WINADVAPI BOOL WINAPI InitializeSid ( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount ); WINADVAPI PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority ( PSID pSid ); WINADVAPI PDWORD WINAPI GetSidSubAuthority ( PSID pSid, DWORD nSubAuthority ); WINADVAPI PUCHAR WINAPI GetSidSubAuthorityCount ( PSID pSid ); WINADVAPI DWORD WINAPI GetLengthSid ( PSID pSid ); WINADVAPI BOOL WINAPI CopySid ( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid ); WINADVAPI BOOL WINAPI AreAllAccessesGranted ( DWORD GrantedAccess, DWORD DesiredAccess ); WINADVAPI BOOL WINAPI AreAnyAccessesGranted ( DWORD GrantedAccess, DWORD DesiredAccess ); WINADVAPI VOID WINAPI MapGenericMask ( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping ); WINADVAPI BOOL WINAPI IsValidAcl ( PACL pAcl ); WINADVAPI BOOL WINAPI InitializeAcl ( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision ); WINADVAPI BOOL WINAPI GetAclInformation ( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass ); WINADVAPI BOOL WINAPI SetAclInformation ( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass ); WINADVAPI BOOL WINAPI AddAce ( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength ); WINADVAPI BOOL WINAPI DeleteAce ( PACL pAcl, DWORD dwAceIndex ); WINADVAPI BOOL WINAPI GetAce ( PACL pAcl, DWORD dwAceIndex, LPVOID *pAce ); WINADVAPI BOOL WINAPI AddAccessAllowedAce ( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI AddAccessAllowedAceEx ( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI AddAccessDeniedAce ( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI AddAccessDeniedAceEx ( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI AddAuditAccessAceEx( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure ); WINADVAPI BOOL WINAPI AddAccessAllowedObjectAce ( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid ); WINADVAPI BOOL WINAPI AddAccessDeniedObjectAce ( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid ); WINADVAPI BOOL WINAPI AddAuditAccessObjectAce ( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, GUID *ObjectTypeGuid, GUID *InheritedObjectTypeGuid, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI FindFirstFreeAce ( PACL pAcl, LPVOID *pAce ); WINADVAPI BOOL WINAPI InitializeSecurityDescriptor ( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision ); WINADVAPI BOOL WINAPI IsValidSecurityDescriptor ( PSECURITY_DESCRIPTOR pSecurityDescriptor ); WINADVAPI DWORD WINAPI GetSecurityDescriptorLength ( PSECURITY_DESCRIPTOR pSecurityDescriptor ); WINADVAPI BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI SetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI SetSecurityDescriptorDacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted ); WINADVAPI BOOL WINAPI GetSecurityDescriptorDacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL *pDacl, LPBOOL lpbDaclDefaulted ); WINADVAPI BOOL WINAPI SetSecurityDescriptorSacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted ); WINADVAPI BOOL WINAPI GetSecurityDescriptorSacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL *pSacl, LPBOOL lpbSaclDefaulted ); WINADVAPI BOOL WINAPI SetSecurityDescriptorOwner ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted ); WINADVAPI BOOL WINAPI GetSecurityDescriptorOwner ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pOwner, LPBOOL lpbOwnerDefaulted ); WINADVAPI BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted ); WINADVAPI BOOL WINAPI GetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pGroup, LPBOOL lpbGroupDefaulted ); WINADVAPI BOOL WINAPI CreatePrivateObjectSecurity ( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI ConvertToAutoInheritPrivateObjectSecurity( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CurrentSecurityDescriptor, PSECURITY_DESCRIPTOR *NewSecurityDescriptor, GUID *ObjectType, BOOLEAN IsDirectoryObject, PGENERIC_MAPPING GenericMapping ); WINADVAPI BOOL WINAPI CreatePrivateObjectSecurityEx ( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, GUID *ObjectType, BOOL IsContainerObject, ULONG AutoInheritFlags, HANDLE Token, PGENERIC_MAPPING GenericMapping ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI SetPrivateObjectSecurity ( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token ); #if(_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI SetPrivateObjectSecurityEx ( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, ULONG AutoInheritFlags, PGENERIC_MAPPING GenericMapping, HANDLE Token OPTIONAL ); #endif /* _WIN32_WINNT >= 0x0500 */ WINADVAPI BOOL WINAPI GetPrivateObjectSecurity ( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength ); WINADVAPI BOOL WINAPI DestroyPrivateObjectSecurity ( PSECURITY_DESCRIPTOR * ObjectDescriptor ); WINADVAPI BOOL WINAPI MakeSelfRelativeSD ( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength ); WINADVAPI 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 ); WINADVAPI BOOL WINAPI SetFileSecurityA ( LPCSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor ); WINADVAPI BOOL WINAPI SetFileSecurityW ( LPCWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor ); #ifdef UNICODE #define SetFileSecurity SetFileSecurityW #else #define SetFileSecurity SetFileSecurityA #endif // !UNICODE WINADVAPI BOOL WINAPI GetFileSecurityA ( LPCSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); WINADVAPI 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 WINADVAPI BOOL WINAPI SetKernelObjectSecurity ( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor ); WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationA( LPCSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter ); WINBASEAPI HANDLE WINAPI FindFirstChangeNotificationW( LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter ); #ifdef UNICODE #define FindFirstChangeNotification FindFirstChangeNotificationW #else #define FindFirstChangeNotification FindFirstChangeNotificationA #endif // !UNICODE WINBASEAPI BOOL WINAPI FindNextChangeNotification( HANDLE hChangeHandle ); WINBASEAPI BOOL WINAPI FindCloseChangeNotification( HANDLE hChangeHandle ); #if(_WIN32_WINNT >= 0x0400) WINBASEAPI BOOL WINAPI ReadDirectoryChangesW( HANDLE hDirectory, LPVOID lpBuffer, DWORD nBufferLength, BOOL bWatchSubtree, DWORD dwNotifyFilter, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ); #endif /* _WIN32_WINNT >= 0x0400 */ WINBASEAPI BOOL WINAPI VirtualLock( LPVOID lpAddress, DWORD dwSize ); WINBASEAPI BOOL WINAPI VirtualUnlock( LPVOID lpAddress, DWORD dwSize ); WINBASEAPI LPVOID WINAPI MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap, LPVOID lpBaseAddress ); WINBASEAPI BOOL WINAPI SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass ); WINBASEAPI DWORD WINAPI GetPriorityClass( HANDLE hProcess ); WINBASEAPI BOOL WINAPI IsBadReadPtr( CONST VOID *lp, UINT ucb ); WINBASEAPI BOOL WINAPI IsBadWritePtr( LPVOID lp, UINT ucb ); WINBASEAPI BOOL WINAPI IsBadHugeReadPtr( CONST VOID *lp, UINT ucb ); WINBASEAPI BOOL WINAPI IsBadHugeWritePtr( LPVOID lp, UINT ucb ); WINBASEAPI BOOL WINAPI IsBadCodePtr( FARPROC lpfn ); WINBASEAPI BOOL WINAPI IsBadStringPtrA( LPCSTR lpsz, UINT ucchMax ); WINBASEAPI BOOL WINAPI IsBadStringPtrW( LPCWSTR lpsz, UINT ucchMax ); #ifdef UNICODE #define IsBadStringPtr IsBadStringPtrW #else #define IsBadStringPtr IsBadStringPtrA #endif // !UNICODE WINADVAPI BOOL WINAPI LookupAccountSidA( LPCSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cbName, LPSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); WINADVAPI 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 WINADVAPI BOOL WINAPI LookupAccountNameA( LPCSTR lpSystemName, LPCSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); WINADVAPI 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 WINADVAPI BOOL WINAPI LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid ); WINADVAPI BOOL WINAPI LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid ); #ifdef UNICODE #define LookupPrivilegeValue LookupPrivilegeValueW #else #define LookupPrivilegeValue LookupPrivilegeValueA #endif // !UNICODE WINADVAPI BOOL WINAPI LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cbName ); WINADVAPI BOOL WINAPI LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cbName ); #ifdef UNICODE #define LookupPrivilegeName LookupPrivilegeNameW #else #define LookupPrivilegeName LookupPrivilegeNameA #endif // !UNICODE WINADVAPI BOOL WINAPI LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName, LPDWORD cbDisplayName, LPDWORD lpLanguageId ); WINADVAPI BOOL WINAPI LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName, LPDWORD cbDisplayName, LPDWORD lpLanguageId ); #ifdef UNICODE #define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameW #else #define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameA #endif // !UNICODE WINADVAPI BOOL WINAPI AllocateLocallyUniqueId( PLUID Luid ); WINBASEAPI BOOL WINAPI BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB ); WINBASEAPI BOOL WINAPI BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB ); #ifdef UNICODE #define BuildCommDCB BuildCommDCBW #else #define BuildCommDCB BuildCommDCBA #endif // !UNICODE WINBASEAPI BOOL WINAPI BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts ); WINBASEAPI BOOL WINAPI BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts ); #ifdef UNICODE #define BuildCommDCBAndTimeouts BuildCommDCBAndTimeoutsW #else #define BuildCommDCBAndTimeouts BuildCommDCBAndTimeoutsA #endif // !UNICODE WINBASEAPI BOOL WINAPI CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC ); WINBASEAPI BOOL WINAPI CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC ); #ifdef UNICODE #define CommConfigDialog CommConfigDialogW #else #define CommConfigDialog CommConfigDialogA #endif // !UNICODE WINBASEAPI BOOL WINAPI GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize ); WINBASEAPI BOOL WINAPI GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize ); #ifdef UNICODE #define GetDefaultCommConfig GetDefaultCommConfigW #else #define GetDefaultCommConfig GetDefaultCommConfigA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize ); WINBASEAPI BOOL WINAPI SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize ); #ifdef UNICODE #define SetDefaultCommConfig SetDefaultCommConfigW #else #define SetDefaultCommConfig SetDefaultCommConfigA #endif // !UNICODE #ifndef _MAC #define MAX_COMPUTERNAME_LENGTH 15 #else #define MAX_COMPUTERNAME_LENGTH 31 #endif WINBASEAPI BOOL WINAPI GetComputerNameA ( LPSTR lpBuffer, LPDWORD nSize ); WINBASEAPI BOOL WINAPI GetComputerNameW ( LPWSTR lpBuffer, LPDWORD nSize ); #ifdef UNICODE #define GetComputerName GetComputerNameW #else #define GetComputerName GetComputerNameA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetComputerNameA ( LPCSTR lpComputerName ); WINBASEAPI BOOL WINAPI SetComputerNameW ( LPCWSTR lpComputerName ); #ifdef UNICODE #define SetComputerName SetComputerNameW #else #define SetComputerName SetComputerNameA #endif // !UNICODE WINADVAPI BOOL WINAPI GetUserNameA ( LPSTR lpBuffer, LPDWORD nSize ); WINADVAPI BOOL WINAPI GetUserNameW ( LPWSTR lpBuffer, LPDWORD nSize ); #ifdef UNICODE #define GetUserName GetUserNameW #else #define GetUserName GetUserNameA #endif // !UNICODE // // Logon Support APIs // #define LOGON32_LOGON_INTERACTIVE 2 #define LOGON32_LOGON_NETWORK 3 #define LOGON32_LOGON_BATCH 4 #define LOGON32_LOGON_SERVICE 5 #define LOGON32_PROVIDER_DEFAULT 0 #define LOGON32_PROVIDER_WINNT35 1 #if(_WIN32_WINNT >= 0x0400) #define LOGON32_PROVIDER_WINNT40 2 #endif /* _WIN32_WINNT >= 0x0400 */ #if(_WIN32_WINNT >= 0x0500) #define LOGON32_PROVIDER_WINNT50 3 #endif // (_WIN32_WINNT >= 0x0500) WINADVAPI BOOL WINAPI LogonUserA ( LPSTR lpszUsername, LPSTR lpszDomain, LPSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken ); WINADVAPI BOOL WINAPI LogonUserW ( LPWSTR lpszUsername, LPWSTR lpszDomain, LPWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken ); #ifdef UNICODE #define LogonUser LogonUserW #else #define LogonUser LogonUserA #endif // !UNICODE WINADVAPI BOOL WINAPI ImpersonateLoggedOnUser( HANDLE hToken ); WINADVAPI BOOL WINAPI CreateProcessAsUserA ( HANDLE hToken, LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); WINADVAPI BOOL WINAPI CreateProcessAsUserW ( HANDLE hToken, LPCWSTR lpApplicationName, LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); #ifdef UNICODE #define CreateProcessAsUser CreateProcessAsUserW #else #define CreateProcessAsUser CreateProcessAsUserA #endif // !UNICODE WINADVAPI BOOL WINAPI DuplicateTokenEx( HANDLE hExistingToken, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE phNewToken); WINADVAPI BOOL APIENTRY CreateRestrictedToken( IN HANDLE ExistingTokenHandle, IN DWORD Flags, IN DWORD DisableSidCount, IN PSID_AND_ATTRIBUTES SidsToDisable OPTIONAL, IN DWORD DeletePrivilegeCount, IN PLUID_AND_ATTRIBUTES PrivilegesToDelete OPTIONAL, IN DWORD RestrictedSidCount, IN PSID_AND_ATTRIBUTES SidsToRestrict OPTIONAL, OUT PHANDLE NewTokenHandle ); WINADVAPI BOOL APIENTRY IsTokenRestricted( IN HANDLE TokenHandle ); #if(_WIN32_WINNT >= 0x0400) // // Plug-and-Play API's // #define HW_PROFILE_GUIDLEN 39 // 36-characters plus NULL terminator #define MAX_PROFILE_LEN 80 #define DOCKINFO_UNDOCKED (0x1) #define DOCKINFO_DOCKED (0x2) #define DOCKINFO_USER_SUPPLIED (0x4) #define DOCKINFO_USER_UNDOCKED (DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED) #define DOCKINFO_USER_DOCKED (DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED) typedef struct tagHW_PROFILE_INFOA { DWORD dwDockInfo; CHAR szHwProfileGuid[HW_PROFILE_GUIDLEN]; CHAR szHwProfileName[MAX_PROFILE_LEN]; } HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA; typedef struct tagHW_PROFILE_INFOW { DWORD dwDockInfo; WCHAR szHwProfileGuid[HW_PROFILE_GUIDLEN]; WCHAR szHwProfileName[MAX_PROFILE_LEN]; } HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW; #ifdef UNICODE typedef HW_PROFILE_INFOW HW_PROFILE_INFO; typedef LPHW_PROFILE_INFOW LPHW_PROFILE_INFO; #else typedef HW_PROFILE_INFOA HW_PROFILE_INFO; typedef LPHW_PROFILE_INFOA LPHW_PROFILE_INFO; #endif // UNICODE WINADVAPI BOOL WINAPI GetCurrentHwProfileA ( OUT LPHW_PROFILE_INFOA lpHwProfileInfo ); WINADVAPI BOOL WINAPI GetCurrentHwProfileW ( OUT LPHW_PROFILE_INFOW lpHwProfileInfo ); #ifdef UNICODE #define GetCurrentHwProfile GetCurrentHwProfileW #else #define GetCurrentHwProfile GetCurrentHwProfileA #endif // !UNICODE #endif /* _WIN32_WINNT >= 0x0400 */ // // Performance counter API's // WINBASEAPI BOOL WINAPI QueryPerformanceCounter( LARGE_INTEGER *lpPerformanceCount ); WINBASEAPI BOOL WINAPI QueryPerformanceFrequency( LARGE_INTEGER *lpFrequency ); typedef struct _OSVERSIONINFOA { DWORD dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; CHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA; typedef struct _OSVERSIONINFOW { DWORD dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; WCHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW; #ifdef UNICODE typedef OSVERSIONINFOW OSVERSIONINFO; typedef POSVERSIONINFOW POSVERSIONINFO; typedef LPOSVERSIONINFOW LPOSVERSIONINFO; #else typedef OSVERSIONINFOA OSVERSIONINFO; typedef POSVERSIONINFOA POSVERSIONINFO; typedef LPOSVERSIONINFOA LPOSVERSIONINFO; #endif // UNICODE typedef struct _OSVERSIONINFOEXA { DWORD dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; CHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage WORD wServicePackMajor; WORD wServicePackMinor; WORD wReserved[2]; } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA; typedef struct _OSVERSIONINFOEXW { DWORD dwOSVersionInfoSize; DWORD dwMajorVersion; DWORD dwMinorVersion; DWORD dwBuildNumber; DWORD dwPlatformId; WCHAR szCSDVersion[ 128 ]; // Maintenance string for PSS usage WORD wServicePackMajor; WORD wServicePackMinor; WORD wReserved[2]; } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW; #ifdef UNICODE typedef OSVERSIONINFOEXW OSVERSIONINFOEX; typedef POSVERSIONINFOEXW POSVERSIONINFOEX; typedef LPOSVERSIONINFOEXW LPOSVERSIONINFOEX; #else typedef OSVERSIONINFOEXA OSVERSIONINFOEX; typedef POSVERSIONINFOEXA POSVERSIONINFOEX; typedef LPOSVERSIONINFOEXA LPOSVERSIONINFOEX; #endif // UNICODE // // dwPlatformId defines: // #define VER_PLATFORM_WIN32s 0 #define VER_PLATFORM_WIN32_WINDOWS 1 #define VER_PLATFORM_WIN32_NT 2 WINBASEAPI BOOL WINAPI GetVersionExA( LPOSVERSIONINFOA lpVersionInformation ); WINBASEAPI BOOL WINAPI GetVersionExW( LPOSVERSIONINFOW lpVersionInformation ); #ifdef UNICODE #define GetVersionEx GetVersionExW #else #define GetVersionEx GetVersionExA #endif // !UNICODE // DOS and OS/2 Compatible Error Code definitions returned by the Win32 Base // API functions. // #include <winerror.h> /* Abnormal termination codes */ #define TC_NORMAL 0 #define TC_HARDERR 1 #define TC_GP_TRAP 2 #define TC_SIGNAL 3 #if(WINVER >= 0x0400) // // Power Management APIs // #define AC_LINE_OFFLINE 0x00 #define AC_LINE_ONLINE 0x01 #define AC_LINE_BACKUP_POWER 0x02 #define AC_LINE_UNKNOWN 0xFF #define BATTERY_FLAG_HIGH 0x01 #define BATTERY_FLAG_LOW 0x02 #define BATTERY_FLAG_CRITICAL 0x04 #define BATTERY_FLAG_CHARGING 0x08 #define BATTERY_FLAG_NO_BATTERY 0x80 #define BATTERY_FLAG_UNKNOWN 0xFF #define BATTERY_PERCENTAGE_UNKNOWN 0xFF #define BATTERY_LIFE_UNKNOWN 0xFFFFFFFF typedef struct _SYSTEM_POWER_STATUS { BYTE ACLineStatus; BYTE BatteryFlag; BYTE BatteryLifePercent; BYTE Reserved1; DWORD BatteryLifeTime; DWORD BatteryFullLifeTime; } SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS; BOOL WINAPI GetSystemPowerStatus( LPSYSTEM_POWER_STATUS lpSystemPowerStatus ); BOOL WINAPI SetSystemPowerState( BOOL fSuspend, BOOL fForce ); #endif /* WINVER >= 0x0400 */ /////////////////////////////////////////////////////////////// // // // Win Certificate API and Structures // // // /////////////////////////////////////////////////////////////// // // Structures // typedef struct _WIN_CERTIFICATE { DWORD dwLength; WORD wRevision; WORD wCertificateType; // WIN_CERT_TYPE_xxx BYTE bCertificate[ANYSIZE_ARRAY]; } WIN_CERTIFICATE, *LPWIN_CERTIFICATE; // // Currently, the only defined certificate revision is WIN_CERT_REVISION_1_0 // #define WIN_CERT_REVISION_1_0 (0x0100) #define WIN_CERT_REVISION_2_0 (0x0200) // // Possible certificate types are specified by the following values // #define WIN_CERT_TYPE_X509 (0x0001) // bCertificate contains an X.509 Certificate #define WIN_CERT_TYPE_PKCS_SIGNED_DATA (0x0002) // bCertificate contains a PKCS SignedData structure #define WIN_CERT_TYPE_RESERVED_1 (0x0003) // Reserved // // API // BOOL WINAPI WinSubmitCertificate( LPWIN_CERTIFICATE lpCertificate ); /////////////////////////////////////////////////////////////// // // // Trust API and Structures // // // /////////////////////////////////////////////////////////////// LONG WINAPI WinVerifyTrust( HWND hwnd, GUID * ActionID, LPVOID ActionData ); BOOL WINAPI WinLoadTrustProvider( GUID * ActionID ); /////////////////////////////////////////////////////////////// // // // Common Trust API Data Structures // // // /////////////////////////////////////////////////////////////// // // Data type commonly used in ActionData structures // typedef LPVOID WIN_TRUST_SUBJECT; // // Two commonly used ActionData structures // typedef struct _WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT { HANDLE hClientToken; GUID * SubjectType; WIN_TRUST_SUBJECT Subject; } WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT, *LPWIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT ; typedef struct _WIN_TRUST_ACTDATA_SUBJECT_ONLY { GUID * SubjectType; WIN_TRUST_SUBJECT Subject; } WIN_TRUST_ACTDATA_SUBJECT_ONLY, *LPWIN_TRUST_ACTDATA_SUBJECT_ONLY; //////////////////////////////////////////////////////////////////// // / // SUBJECT FORM DEFINITIONS / // / //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // / // Currently defined Subject Type Identifiers. All of the below / // use the WIN_TRUST_SUBJECT_FILE subject form, defined below. / // / //////////////////////////////////////////////////////////////////// /* RawFile == 959dc450-8d9e-11cf-8736-00aa00a485eb */ #define WIN_TRUST_SUBJTYPE_RAW_FILE \ { 0x959dc450, \ 0x8d9e, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } /* PeImage == 43c9a1e0-8da0-11cf-8736-00aa00a485eb */ #define WIN_TRUST_SUBJTYPE_PE_IMAGE \ { 0x43c9a1e0, \ 0x8da0, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } /* JavaClass = 08ad3990-8da1-11cf-8736-00aa00a485eb */ #define WIN_TRUST_SUBJTYPE_JAVA_CLASS \ { 0x08ad3990, \ 0x8da1, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } /* Cabinet = d17c5374-a392-11cf-9df5-00aa00c184e0 */ #define WIN_TRUST_SUBJTYPE_CABINET \ { 0xd17c5374, \ 0xa392, \ 0x11cf, \ { 0x9d, 0xf5, 0x0, 0xaa, 0x0, 0xc1, 0x84, 0xe0 } \ } // // Associated Subject Data Structure: // typedef struct _WIN_TRUST_SUBJECT_FILE { HANDLE hFile; LPCWSTR lpPath; } WIN_TRUST_SUBJECT_FILE, *LPWIN_TRUST_SUBJECT_FILE; //////////////////////////////////////////////////////////////////// // / // The following subject types use the / // WIN_TRUST_SUBJECT_FILE_AND_DISPLAY subject type, defined / // below. / // / //////////////////////////////////////////////////////////////////// #define WIN_TRUST_SUBJTYPE_RAW_FILEEX \ { 0x6f458110, \ 0xc2f1, \ 0x11cf, \ { 0x8a, 0x69, 0x0, 0xaa, 0x0, 0x6c, 0x37, 0x6 } \ } #define WIN_TRUST_SUBJTYPE_PE_IMAGEEX \ { 0x6f458111, \ 0xc2f1, \ 0x11cf, \ { 0x8a, 0x69, 0x0, 0xaa, 0x0, 0x6c, 0x37, 0x6 } \ } #define WIN_TRUST_SUBJTYPE_JAVA_CLASSEX \ { 0x6f458113, \ 0xc2f1, \ 0x11cf, \ { 0x8a, 0x69, 0x0, 0xaa, 0x0, 0x6c, 0x37, 0x6 } \ } #define WIN_TRUST_SUBJTYPE_CABINETEX \ { 0x6f458114, \ 0xc2f1, \ 0x11cf, \ { 0x8a, 0x69, 0x0, 0xaa, 0x0, 0x6c, 0x37, 0x6 } \ } // // Associated Subject Data Structure: // typedef struct _WIN_TRUST_SUBJECT_FILE_AND_DISPLAY { HANDLE hFile; // handle to the open file if you got it LPCWSTR lpPath; // the path to open if you don't LPCWSTR lpDisplayName; // (optional) display name to show to user // in place of path } WIN_TRUST_SUBJECT_FILE_AND_DISPLAY, *LPWIN_TRUST_SUBJECT_FILE_AND_DISPLAY; //////////////////////////////////////////////////////////////////// // / // Other subject types: / // / //////////////////////////////////////////////////////////////////// /* OleStorage == c257e740-8da0-11cf-8736-00aa00a485eb */ #define WIN_TRUST_SUBJTYPE_OLE_STORAGE \ { 0xc257e740, \ 0x8da0, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } //////////////////////////////////////////////////////////////////// // / // TRUST PROVIDER SPECIFIC DEFINITIONS / // / // / // Each trust provider will have the following / // sections defined: / // / // Actions - What actions are supported by the trust / // provider. / // / // SubjectForms - Subjects that may be evaluated by this / // trust provider. / // / // and / // / // Data structures to support the subject forms. / // / // / //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// // / // Software Publisher Trust Provider / // / //////////////////////////////////////////////////////////////////// // // Actions: // /* TrustedPublisher == 66426730-8da1-11cf-8736-00aa00a485eb */ #define WIN_SPUB_ACTION_TRUSTED_PUBLISHER \ { 0x66426730, \ 0x8da1, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } /* NtActivateImage == 8bc96b00-8da1-11cf-8736-00aa00a485eb */ #define WIN_SPUB_ACTION_NT_ACTIVATE_IMAGE \ { 0x8bc96b00, \ 0x8da1, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } /* PublishedSoftware == 64b9d180-8da2-11cf-8736-00aa00a485eb */ #define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE \ { 0x64b9d180, \ 0x8da2, \ 0x11cf, \ {0x87, 0x36, 0x00, 0xaa, 0x00, 0xa4, 0x85, 0xeb} \ } // // Data Structures: // // WIN_SPUB_ACTION_TRUSTED_PUBLISHER: // // Uses WIN_SPUB_TRUSTED_PUBLISHER_DATA // // WIN_SPUB_ACTION_NT_ACTIVATE_IMAGE: // // Uses WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT // // WIN_SPUB_ACTION_PUBLISHED_SOFTWARE: // // Uses WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT // typedef struct _WIN_SPUB_TRUSTED_PUBLISHER_DATA { HANDLE hClientToken; LPWIN_CERTIFICATE lpCertificate; } WIN_SPUB_TRUSTED_PUBLISHER_DATA, *LPWIN_SPUB_TRUSTED_PUBLISHER_DATA; #if (_WIN32_WINNT >= 0x0500) // // Very Large Memory API Subset // WINBASEAPI PVOID64 WINAPI VirtualAllocVlm( HANDLE hProcess, PVOID64 lpAddress, DWORDLONG ullSize, DWORD flAllocationType, DWORD flProtect ); WINBASEAPI BOOL WINAPI VirtualFreeVlm( HANDLE hProcess, PVOID64 lpAddress, DWORDLONG ullSize, DWORD dwFreeType ); WINBASEAPI BOOL WINAPI VirtualProtectVlm( HANDLE hProcess, PVOID64 lpAddress, DWORDLONG ullSize, DWORD flNewProtect, PDWORD lpflOldProtect ); WINBASEAPI DWORD WINAPI VirtualQueryVlm( HANDLE hProcess, PVOID64 lpAddress, PMEMORY_BASIC_INFORMATION_VLM lpBuffer, DWORD dwLength ); typedef struct _MEMORYSTATUSVLM { DWORD dwLength; DWORD dwMemoryLoad; DWORDLONG ullTotalPhys; DWORDLONG ullAvailPhys; DWORDLONG ullTotalPageFile; DWORDLONG ullAvailPageFile; DWORDLONG ullTotalVirtual; DWORDLONG ullAvailVirtual; DWORDLONG ullAvailExtendedVirtual; } MEMORYSTATUSVLM, *LPMEMORYSTATUSVLM; WINBASEAPI VOID WINAPI GlobalMemoryStatusVlm( LPMEMORYSTATUSVLM lpBuffer ); WINBASEAPI BOOL WINAPI ReadProcessMemoryVlm( HANDLE hProcess, PVOID64 lpBaseAddress, PVOID64 lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead ); WINBASEAPI BOOL WINAPI WriteProcessMemoryVlm( HANDLE hProcess, PVOID64 lpBaseAddress, PVOID64 lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesWritten ); WINBASEAPI BOOL WINAPI ReadFileVlm( HANDLE hFile, PVOID64 lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped ); WINBASEAPI BOOL WINAPI WriteFileVlm( HANDLE hFile, PVOID64 lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped ); WINBASEAPI HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName ); #ifdef UNICODE #define CreateJobObject CreateJobObjectW #else #define CreateJobObject CreateJobObjectA #endif // !UNICODE WINBASEAPI HANDLE WINAPI OpenJobObjectA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName ); WINBASEAPI HANDLE WINAPI OpenJobObjectW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName ); #ifdef UNICODE #define OpenJobObject OpenJobObjectW #else #define OpenJobObject OpenJobObjectA #endif // !UNICODE WINBASEAPI BOOL WINAPI AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess ); WINBASEAPI BOOL WINAPI TerminateJobObject( HANDLE hJob, UINT uExitCode ); WINBASEAPI BOOL WINAPI QueryInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength ); WINBASEAPI BOOL WINAPI SetInformationJobObject( HANDLE hJob, JOBOBJECTINFOCLASS JobObjectInformationClass, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength ); #endif // (_WIN32_WINNT >= 0x0500) #ifdef __cplusplus } #endif #endif // _WINBASE_