7746 lines
144 KiB
C
7746 lines
144 KiB
C
/************************************************************************
|
|
* *
|
|
* 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_
|