/************************************************************************
* *
* winbase.h -- This module defines the 32-Bit Windows Base APIs *
* *
* Copyright (c) 1990-1996, Microsoft Corp. All rights reserved. *
* *
************************************************************************/
#ifndef _WINBASE_
#define _WINBASE_
//
// 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
#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
//
// 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 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
#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
#define GetFreeSpace(w) (0x100000L)
#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)
int
WINAPI
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
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
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
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 */
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 >= 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
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
BOOL
WINAPI
FlushViewOfFile(
LPCVOID lpBaseAddress,
DWORD dwNumberOfBytesToFlush
);
WINBASEAPI
BOOL
WINAPI
UnmapViewOfFile(
LPCVOID lpBaseAddress
);
//
// _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
//
// Stream Attributes
//
#define STREAM_NORMAL_ATTRIBUTE 0x00000000
#define STREAM_MODIFIED_WHEN_READ 0x00000001
#define STREAM_CONTAINS_SECURITY 0x00000002
#define STREAM_CONTAINS_PROPERTIES 0x00000004
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 ];
} 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 ];
} 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)
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 */
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
#define MOVEFILE_REPLACE_EXISTING 0x00000001
#define MOVEFILE_COPY_ALLOWED 0x00000002
#define MOVEFILE_DELAY_UNTIL_REBOOT 0x00000004
#define MOVEFILE_WRITE_THROUGH 0x00000008
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
);
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
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
);
WINADVAPI
BOOL
WINAPI
AddAccessDeniedAce (
PACL pAcl,
DWORD dwAceRevision,
DWORD AccessMask,
PSID pSid
);
WINADVAPI
BOOL
WINAPI
AddAuditAccessAce(
PACL pAcl,
DWORD dwAceRevision,
DWORD dwAccessMask,
PSID pSid,
BOOL bAuditSuccess,
BOOL bAuditFailure
);
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
);
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
);
WINADVAPI
BOOL
WINAPI
SetPrivateObjectSecurity (
SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR ModificationDescriptor,
PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
PGENERIC_MAPPING GenericMapping,
HANDLE Token
);
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
#define MAX_COMPUTERNAME_LENGTH 15
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 */
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);
#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
//
// 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)
//
// 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;
#ifdef __cplusplus
}
#endif
#endif // _WINBASE_
