mstools/mfc/include/winbase.h - view

File: [WindowsNT SDKs] / mstools / mfc / include / winbase.h
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Thu Aug 9 18:21:00 2018 UTC (7 years, 9 months ago) by root
Branches: msft, MAIN
CVS tags: ntsdk-jun-1992, HEAD

Microsoft Windows NT Build 297 06-28-1992

/*++ BUILD Version: 0001 // Increment this if a change has global effects Copyright (c) 1990 Microsoft Corporation Module Name: winbase.h Abstract: This module defines the 32-Bit Windows Base APIs Created: 18-Sep-1990 Revision History: --*/ #ifndef _WINBASE_ #define _WINBASE_ /* * Compatability 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 FILE_BEGIN 0 #define FILE_CURRENT 1 #define FILE_END 2 #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 CONTROL_C_EXIT STATUS_CONTROL_C_EXIT // // 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 CREATE_NEW 1 #define CREATE_ALWAYS 2 #define OPEN_EXISTING 3 #define OPEN_ALWAYS 4 #define TRUNCATE_EXISTING 5 // // 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 // // Special values for mailslot information. // // // Special value for NextMessageSize to indicate that there is no next // message. // #define MAILSLOT_NO_MESSAGE ((ULONG)-1) // // Special value for read timeout to indicate that mailslot reads should // never timeout. // #define MAILSLOT_WAIT_FOREVER ((ULONG)-1) // // 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 (*PTHREAD_START_ROUTINE)( LPVOID lpThreadParameter ); typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; typedef RTL_CRITICAL_SECTION CRITICAL_SECTION; typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION; typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION; #ifdef i386 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_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_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; 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 : 17; 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:1; /* 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; /* Recieved Event character */ } 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 _SYSTEM_INFO { DWORD dwOemId; DWORD dwPageSize; LPVOID lpMinimumApplicationAddress; LPVOID lpMaximumApplicationAddress; DWORD dwActiveProcessorMask; DWORD dwNumberOfProcessors; DWORD dwProcessorType; DWORD dwProcessorRevision; DWORD dwProcessorOptions; } SYSTEM_INFO, *LPSYSTEM_INFO; #define FreeModule(hLibModule) FreeLibrary((hLibModule)) #define MakeProcInstance(lpProc,hInstance) (lpProc) #define FreeProcInstance(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 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) // // 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; 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; LPTHREAD_START_ROUTINE lpStartAddress; } 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; } 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_THREAD_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; typedef PCONTEXT LPCONTEXT; typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD; typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS; #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 // // Basud 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_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 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; BYTE szPathName[OFS_MAXPATHNAME]; } OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT; LONG WINAPI InterlockedIncrement( LPLONG lpAddend ); LONG WINAPI InterlockedDecrement( LPLONG lpAddend ); BOOL WINAPI FreeResource( HGLOBAL hResData ); 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 ); BOOL WINAPI FreeLibrary( HINSTANCE hLibModule ); FARPROC WINAPI GetProcAddress( HINSTANCE hModule, LPCSTR lpProcName ); DWORD WINAPI GetVersion( VOID ); HGLOBAL WINAPI GlobalAlloc( UINT uFlags, DWORD dwBytes ); HGLOBAL WINAPI GlobalReAlloc( HGLOBAL hMem, DWORD dwBytes, UINT uFlags ); DWORD WINAPI GlobalSize( HGLOBAL hMem ); UINT WINAPI GlobalFlags( HGLOBAL hMem ); LPVOID WINAPI GlobalLock( HGLOBAL hMem ); //!!!MWH My version win31 = DWORD WINAPI GlobalHandle(UINT) HGLOBAL WINAPI GlobalHandle( LPVOID pMem ); BOOL WINAPI GlobalUnlock( HGLOBAL hMem ); HGLOBAL WINAPI GlobalFree( HGLOBAL hMem ); UINT WINAPI GlobalCompact( DWORD dwMinFree ); VOID WINAPI GlobalFix( HGLOBAL hMem ); VOID WINAPI GlobalUnfix( HGLOBAL hMem ); LPVOID WINAPI GlobalWire( HGLOBAL hMem ); BOOL WINAPI GlobalUnWire( HGLOBAL hMem ); VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ); HLOCAL WINAPI LocalAlloc( UINT uFlags, UINT uBytes ); HLOCAL WINAPI LocalReAlloc( HLOCAL hMem, UINT uBytes, UINT uFlags ); LPVOID WINAPI LocalLock( HLOCAL hMem ); HLOCAL WINAPI LocalHandle( LPVOID pMem ); BOOL WINAPI LocalUnlock( HLOCAL hMem ); UINT WINAPI LocalSize( HLOCAL hMem ); UINT WINAPI LocalFlags( HLOCAL hMem ); HLOCAL WINAPI LocalFree( HLOCAL hMem ); UINT WINAPI LocalShrink( HLOCAL hMem, UINT cbNewSize ); UINT WINAPI LocalCompact( UINT uMinFree ); BOOL WINAPI FlushInstructionCache( HANDLE hProcess, LPVOID lpBaseAddress, DWORD dwSize ); LPVOID WINAPI VirtualAlloc( LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect ); BOOL WINAPI VirtualFree( LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType ); BOOL WINAPI VirtualProtect( LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect ); DWORD WINAPI VirtualQuery( LPVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength ); BOOL WINAPI VirtualProtectEx( HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect ); DWORD WINAPI VirtualQueryEx( HANDLE hProcess, LPVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength ); HANDLE WINAPI HeapCreate( DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize ); BOOL WINAPI HeapDestroy( HANDLE hHeap ); LPSTR WINAPI HeapAlloc( HANDLE hHeap, DWORD dwBytes ); BOOL WINAPI HeapFree( HANDLE hHeap, LPSTR lpMem ); DWORD WINAPI HeapSize( HANDLE hHeap, LPSTR lpMem ); HANDLE WINAPI OpenProcess( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwProcessId ); HANDLE WINAPI GetCurrentProcess( VOID ); DWORD WINAPI GetCurrentProcessId( VOID ); VOID WINAPI ExitProcess( UINT uExitCode ); BOOL WINAPI TerminateProcess( HANDLE hProcess, UINT uExitCode ); BOOL WINAPI GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode ); VOID WINAPI FatalExit( int ExitCode ); LPVOID WINAPI GetEnvironmentStrings( VOID ); VOID WINAPI RaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments, LPDWORD lpArguments ); EXCEPTION_DISPOSITION WINAPI UnhandledExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo ); HANDLE WINAPI CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); HANDLE WINAPI GetCurrentThread( VOID ); DWORD WINAPI GetCurrentThreadId( VOID ); BOOL WINAPI SetThreadPriority( HANDLE hThread, int nPriority ); int WINAPI GetThreadPriority( HANDLE hThread ); VOID WINAPI ExitThread( DWORD dwExitCode ); BOOL WINAPI TerminateThread( HANDLE hThread, DWORD dwExitCode ); BOOL WINAPI GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode ); BOOL WINAPI GetThreadSelectorEntry( HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry ); DWORD WINAPI GetLastError( VOID ); VOID WINAPI SetLastError( DWORD dwErrCode ); // // SetLastErrorEx() types. // #define SLE_ERROR 0x00000001 #define SLE_MINORERROR 0x00000002 #define SLE_WARNING 0x00000003 VOID SetLastErrorEx( DWORD dwErrCode, DWORD dwType ); BOOL WINAPI GetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait ); #define SEM_FAILCRITICALERRORS 0x0001 #define SEM_NOGPFAULTERRORBOX 0x0002 #define SEM_NOOPENFILEERRORBOX 0x8000 VOID WINAPI SetDebugErrorLevel( DWORD dwLevel ); UINT WINAPI SetErrorMode( UINT uMode ); BOOL WINAPI ReadProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead ); BOOL WINAPI WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesWritten ); BOOL WINAPI GetThreadContext( HANDLE hThread, LPCONTEXT lpContext ); BOOL WINAPI SetThreadContext( HANDLE hThread, LPCONTEXT lpContext ); DWORD WINAPI SuspendThread( HANDLE hThread ); DWORD WINAPI ResumeThread( HANDLE hThread ); VOID WINAPI DebugBreak( VOID ); BOOL WINAPI WaitForDebugEvent( LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds ); BOOL WINAPI ContinueDebugEvent( DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus ); BOOL WINAPI DebugActiveProcess( DWORD dwProcessId ); HANDLE WINAPI DebugSnapShotProcessHeaps( DWORD dwProcessId ); typedef struct _DEBUG_HEAP_BACKTRACE { DWORD Depth; DWORD ReturnAddresses[ 1 ]; } DEBUG_HEAP_BACKTRACE, *PDEBUG_HEAP_BACKTRACE; typedef struct _DEBUG_HEAP_ALLOCATOR { DWORD TotalBytesAllocated; DWORD OffsetToBackTrace; } DEBUG_HEAP_ALLOCATOR, *PDEBUG_HEAP_ALLOCATOR; typedef struct _DEBUG_HEAP_ENTRY { DWORD Address; USHORT Size; USHORT Allocator; } DEBUG_HEAP_ENTRY, *PDEBUG_HEAP_ENTRY; #define DEBUG_HEAP_ENTRY_FREE (USHORT)-1 typedef struct _DEBUG_HEAP_INFO { USHORT Creator; USHORT HeaderSizeLog2; USHORT ReservedPages; USHORT CommittedPages; USHORT AllocatorReservedPages; USHORT AllocatorCommittedPages; DWORD NumberOfEntries; DEBUG_HEAP_ENTRY Entries[ 1 ]; } DEBUG_HEAP_INFO, *PDEBUG_HEAP_INFO; typedef struct _DEBUG_HEAP_DUMP { DWORD OffsetToAllocatorTable; DWORD NumberOfHeaps; DEBUG_HEAP_INFO HeapInfo[ 1 ]; } DEBUG_HEAP_DUMP, *PDEBUG_HEAP_DUMP; VOID WINAPI InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID WINAPI EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID WINAPI LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); VOID WINAPI DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); BOOL WINAPI SetEvent( HANDLE hEvent ); BOOL WINAPI ResetEvent( HANDLE hEvent ); BOOL WINAPI PulseEvent( HANDLE hEvent ); BOOL WINAPI ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount ); BOOL WINAPI ReleaseMutex( HANDLE hMutex ); DWORD WINAPI WaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds ); DWORD WINAPI WaitForMultipleObjects( DWORD nCount, LPHANDLE lpHandles, BOOL bWaitAll, DWORD dwMilliseconds ); VOID WINAPI Sleep( DWORD dwMilliseconds ); HRSRC WINAPI LoadResource( HINSTANCE hModule, HRSRC hResInfo ); DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hResInfo ); ATOM WINAPI GlobalDeleteAtom( ATOM nAtom ); BOOL WINAPI InitAtomTable( DWORD nSize ); ATOM WINAPI DeleteAtom( ATOM nAtom ); UINT WINAPI SetHandleCount( UINT uNumber ); DWORD WINAPI GetLogicalDrives( VOID ); BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh ); BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh ); typedef struct _BY_HANDLE_FILE_INFORMATION { DWORD dwFileAttributes; FILETIME ftCreationTime; FILETIME ftLastAccessTime; FILETIME ftLastWriteTime; DWORD dwVolumeSerialNumber; DWORD nFileSizeHigh; DWORD nFileSizeLow; DWORD nNumberOfLinks; DWORD nFileIndexHigh; DWORD nFileIndexLow; } BY_HANDLE_FILE_INFORMATION, *PBY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION; BOOL WINAPI GetFileInformationByHandle( HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation ); DWORD WINAPI GetFileType( HANDLE hFile ); DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh ); HANDLE WINAPI GetStdHandle( DWORD nStdHandle ); BOOL WINAPI SetStdHandle( DWORD nStdHandle, HANDLE hHandle ); BOOL WINAPI WriteFile( HANDLE hFile, CONST VOID *lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped ); BOOL WINAPI ReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped ); BOOL WINAPI FlushFileBuffers( HANDLE hFile ); BOOL WINAPI DeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped ); BOOL WINAPI SetEndOfFile( HANDLE hFile ); DWORD WINAPI SetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod ); BOOL WINAPI FindClose( HANDLE hFindFile ); BOOL WINAPI GetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime ); BOOL WINAPI SetFileTime( HANDLE hFile, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime ); BOOL WINAPI CloseHandle( HANDLE hObject ); BOOL WINAPI DuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions ); DWORD WINAPI LoadModule( LPCSTR lpModuleName, LPVOID lpParameterBlock ); UINT WINAPI WinExec( LPCSTR lpCmdLine, UINT uCmdShow ); BOOL WINAPI BuildCommDCB( LPSTR lpDef, LPDCB lpDCB ); BOOL WINAPI ClearCommBreak( HANDLE hFile ); BOOL WINAPI ClearCommError( HANDLE hFile, LPDWORD lpErrors, LPCOMSTAT lpStat ); BOOL WINAPI SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue ); BOOL WINAPI EscapeCommFunction( HANDLE hFile, DWORD dwFunc ); BOOL WINAPI GetCommMask( HANDLE hFile, LPDWORD lpEvtMask ); BOOL WINAPI GetCommProperties( HANDLE hFile, LPCOMMPROP lpCommProp ); BOOL WINAPI GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat ); BOOL WINAPI GetCommState( HANDLE hFile, LPDCB lpDCB ); BOOL WINAPI GetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); BOOL WINAPI PurgeComm( HANDLE hFile, DWORD dwFlags ); BOOL WINAPI SetCommBreak( HANDLE hFile ); BOOL WINAPI SetCommMask( HANDLE hFile, DWORD dwEvtMask ); BOOL WINAPI SetCommState( HANDLE hFile, LPDCB lpDCB ); BOOL WINAPI SetCommTimeouts( HANDLE hFile, LPCOMMTIMEOUTS lpCommTimeouts ); BOOL WINAPI TransmitCommChar( HANDLE hFile, char cChar ); BOOL WINAPI WaitCommEvent( HANDLE hFile, LPDWORD lpEvtMask, LPOVERLAPPED lpOverlapped ); DWORD WINAPI SetTapePosition( HANDLE hDevice, DWORD dwPositionMethod, DWORD dwPartition, DWORD dwOffset, LPDWORD lpdwOffsetHigh, LPOVERLAPPED lpOverlapped ); DWORD WINAPI GetTapePosition( HANDLE hDevice, DWORD dwPartition, LPDWORD lpdwOffsetHigh, LPOVERLAPPED lpOverlapped ); DWORD WINAPI PrepareTape( HANDLE hDevice, DWORD dwTapeOperation, LPOVERLAPPED lpOverlapped ); DWORD WINAPI EraseTape( HANDLE hDevice, DWORD dwPartition, DWORD dwEraseType, LPOVERLAPPED lpOverlapped ); DWORD CreateTapePartition( HANDLE hDevice, DWORD dwSize, LPVOID lpPartitionParameters, LPOVERLAPPED lpOverlapped ); DWORD WINAPI WriteTapemark( HANDLE hDevice, DWORD dwTapemarkType, DWORD dwTapemarkCount, LPOVERLAPPED lpOverlapped ); DWORD WINAPI GetTapeStatus( HANDLE hDevice, LPVOID lpTapeStatus, LPOVERLAPPED lpOverlapped ); DWORD WINAPI GetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation, LPOVERLAPPED lpOverlapped ); #define GET_TAPE_MEDIA_INFORMATION 0 #define GET_TAPE_DRIVE_INFORMATION 1 DWORD WINAPI SetTapeParameters( HANDLE hDevice, DWORD dwOperation, LPVOID lpTapeInformation, LPOVERLAPPED lpOverlapped ); #define SET_TAPE_MEDIA_INFORMATION 0 #define SET_TAPE_DRIVE_INFORMATION 1 BOOL WINAPI Beep( DWORD dwFreq, DWORD dwDuration ); VOID WINAPI OpenSound( VOID ); VOID WINAPI CloseSound( VOID ); VOID WINAPI StartSound( VOID ); VOID WINAPI StopSound( VOID ); DWORD WINAPI WaitSoundState( DWORD nState ); DWORD WINAPI SyncAllVoices( VOID ); DWORD WINAPI CountVoiceNotes( DWORD nVoice ); LPDWORD WINAPI GetThresholdEvent( VOID ); DWORD WINAPI GetThresholdStatus( VOID ); DWORD WINAPI SetSoundNoise( DWORD nSource, DWORD nDuration ); DWORD WINAPI SetVoiceAccent( DWORD nVoice, DWORD nTempo, DWORD nVolume, DWORD nMode, DWORD nPitch ); DWORD WINAPI SetVoiceEnvelope( DWORD nVoice, DWORD nShape, DWORD nRepeat ); DWORD WINAPI SetVoiceNote( DWORD nVoice, DWORD nValue, DWORD nLength, DWORD nCdots ); DWORD WINAPI SetVoiceQueueSize( DWORD nVoice, DWORD nBytes ); DWORD WINAPI SetVoiceSound( DWORD nVoice, DWORD Frequency, DWORD nDuration ); DWORD WINAPI SetVoiceThreshold( DWORD nVoice, DWORD nNotes ); int WINAPI MulDiv( int nNumber, int nNumerator, int nDenominator ); VOID WINAPI GetSystemTime( LPSYSTEMTIME lpSystemTime ); BOOL WINAPI SetSystemTime( LPSYSTEMTIME lpSystemTime ); VOID WINAPI GetSystemInfo( LPSYSTEM_INFO lpSystemInfo ); // // Routines to convert back and forth between system time and file time // BOOL WINAPI SystemTimeToFileTime( LPSYSTEMTIME lpSystemTime, LPFILETIME lpFileTime ); BOOL WINAPI FileTimeToSystemTime( LPFILETIME lpFileTime, LPSYSTEMTIME lpSystemTime ); LONG WINAPI CompareFileTime( LPFILETIME lpFileTime1, LPFILETIME lpFileTime2 ); BOOL WINAPI FileTimeToDosDateTime( LPFILETIME lpFileTime, LPWORD lpFatDate, LPWORD lpFatTime ); BOOL WINAPI DosDateTimeToFileTime( WORD wFatDate, WORD wFatTime, LPFILETIME lpFileTime ); DWORD WINAPI GetTickCount( VOID ); DWORD WINAPI FormatMessage( DWORD dwFlags, LPVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, LPVOID lpArguments ); #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_MAX_WIDTH_MASK 0x000000FF BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize ); BOOL WINAPI ConnectNamedPipe( HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped ); BOOL WINAPI DisconnectNamedPipe( HANDLE hNamedPipe ); BOOL WINAPI SetNamedPipeHandleState( HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout ); BOOL WINAPI GetNamedPipeInfo( HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutBufferSize, LPDWORD lpInBufferSize, LPDWORD lpMaxInstances ); BOOL WINAPI PeekNamedPipe( HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage ); BOOL WINAPI TransactNamedPipe( HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped ); HANDLE WINAPI CreateMailslotA( LPSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); HANDLE WINAPI CreateMailslotW( LPWSTR lpName, DWORD nMaxMessageSize, DWORD lReadTimeout, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateMailslot CreateMailslotW #else #define CreateMailslot CreateMailslotA #endif // !UNICODE BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout ); BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD lReadTimeout ); LPVOID WINAPI MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap ); BOOL WINAPI FlushViewOfFile( LPVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush ); BOOL WINAPI UnmapViewOfFile( LPVOID lpBaseAddress ); // // _l Compat Functions // int WINAPI lstrcmpA( LPCSTR lpString1, LPCSTR lpString2 ); int WINAPI lstrcmpW( LPCWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcmp lstrcmpW #else #define lstrcmp lstrcmpA #endif // !UNICODE int WINAPI lstrcmpiA( LPCSTR lpString1, LPCSTR lpString2 ); int WINAPI lstrcmpiW( LPCWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcmpi lstrcmpiW #else #define lstrcmpi lstrcmpiA #endif // !UNICODE LPSTR WINAPI lstrcpyA( LPSTR lpString1, LPCSTR lpString2 ); LPWSTR WINAPI lstrcpyW( LPWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcpy lstrcpyW #else #define lstrcpy lstrcpyA #endif // !UNICODE LPSTR WINAPI lstrcatA( LPSTR lpString1, LPCSTR lpString2 ); LPWSTR WINAPI lstrcatW( LPWSTR lpString1, LPCWSTR lpString2 ); #ifdef UNICODE #define lstrcat lstrcatW #else #define lstrcat lstrcatA #endif // !UNICODE int WINAPI lstrlenA( LPCSTR lpString ); int WINAPI lstrlenW( LPCWSTR lpString ); #ifdef UNICODE #define lstrlen lstrlenW #else #define lstrlen lstrlenA #endif // !UNICODE HFILE WINAPI OpenFile( LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle ); HFILE WINAPI _lopen( LPCSTR lpPathName, int iReadWrite ); HFILE WINAPI _lcreat( LPCSTR lpPathName, int iAttribute ); UINT WINAPI _lread( HFILE hFile, LPVOID lpBuffer, UINT uBytes ); UINT WINAPI _lwrite( HFILE hFile, LPCSTR lpBuffer, UINT uBytes ); HFILE WINAPI _lclose( HFILE hFile ); LONG WINAPI _llseek( HFILE hFile, LONG lOffset, int iOrigin ); DWORD WINAPI TlsAlloc( VOID ); LPVOID WINAPI TlsGetValue( DWORD dwTlsIndex ); BOOL WINAPI TlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue ); BOOL WINAPI TlsFree( DWORD dwTlsIndex ); typedef VOID (*LPOVERLAPPED_COMPLETION_ROUTINE)( DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped ); DWORD WINAPI SleepEx( DWORD dwMilliseconds, BOOL bAlertable ); DWORD WINAPI WaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable ); DWORD WINAPI WaitForMultipleObjectsEx( DWORD nCount, LPHANDLE lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable ); BOOL WINAPI ReadFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ); BOOL WINAPI WriteFileEx( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine ); BOOL WINAPI BackupRead( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, BOOL fAbort , LPVOID *lpContext ); BOOL WINAPI BackupWrite( HANDLE hFile, LPBYTE lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, BOOL fAbort , LPVOID *lpContext ); // // 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 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; } 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; } STARTUPINFOW, *LPSTARTUPINFOW; #ifdef UNICODE #define STARTUPINFO STARTUPINFOW #define LPSTARTUPINFO LPSTARTUPINFOW #else #define STARTUPINFO STARTUPINFOA #define LPSTARTUPINFO LPSTARTUPINFOA #endif // UNICODE 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 #define WIN32_FIND_DATA WIN32_FIND_DATAW #define PWIN32_FIND_DATA PWIN32_FIND_DATAW #define LPWIN32_FIND_DATA LPWIN32_FIND_DATAW #else #define WIN32_FIND_DATA WIN32_FIND_DATAA #define PWIN32_FIND_DATA PWIN32_FIND_DATAA #define LPWIN32_FIND_DATA LPWIN32_FIND_DATAA #endif // UNICODE HANDLE WINAPI CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPSTR lpName ); HANDLE WINAPI CreateMutexW( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPWSTR lpName ); #ifdef UNICODE #define CreateMutex CreateMutexW #else #define CreateMutex CreateMutexA #endif // !UNICODE HANDLE WINAPI OpenMutexA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPSTR lpName ); HANDLE WINAPI OpenMutexW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPWSTR lpName ); #ifdef UNICODE #define OpenMutex OpenMutexW #else #define OpenMutex OpenMutexA #endif // !UNICODE HANDLE WINAPI CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPSTR lpName ); HANDLE WINAPI CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPWSTR lpName ); #ifdef UNICODE #define CreateEvent CreateEventW #else #define CreateEvent CreateEventA #endif // !UNICODE HANDLE WINAPI OpenEventA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPSTR lpName ); HANDLE WINAPI OpenEventW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPWSTR lpName ); #ifdef UNICODE #define OpenEvent OpenEventW #else #define OpenEvent OpenEventA #endif // !UNICODE HANDLE WINAPI CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPSTR lpName ); HANDLE WINAPI CreateSemaphoreW( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPWSTR lpName ); #ifdef UNICODE #define CreateSemaphore CreateSemaphoreW #else #define CreateSemaphore CreateSemaphoreA #endif // !UNICODE HANDLE WINAPI OpenSemaphoreA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPSTR lpName ); HANDLE WINAPI OpenSemaphoreW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPWSTR lpName ); #ifdef UNICODE #define OpenSemaphore OpenSemaphoreW #else #define OpenSemaphore OpenSemaphoreA #endif // !UNICODE HANDLE WINAPI CreateFileMappingA( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPSTR lpName ); HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPWSTR lpName ); #ifdef UNICODE #define CreateFileMapping CreateFileMappingW #else #define CreateFileMapping CreateFileMappingA #endif // !UNICODE HANDLE WINAPI OpenFileMappingA( DWORD dwDesiredAccess, BOOL bInheritHandle, LPSTR lpName ); HANDLE WINAPI OpenFileMappingW( DWORD dwDesiredAccess, BOOL bInheritHandle, LPWSTR lpName ); #ifdef UNICODE #define OpenFileMapping OpenFileMappingW #else #define OpenFileMapping OpenFileMappingA #endif // !UNICODE DWORD WINAPI GetLogicalDriveStringsA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD WINAPI GetLogicalDriveStringsW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetLogicalDriveStrings GetLogicalDriveStringsW #else #define GetLogicalDriveStrings GetLogicalDriveStringsA #endif // !UNICODE HINSTANCE WINAPI LoadLibraryA( LPCSTR lpLibFileName ); HINSTANCE WINAPI LoadLibraryW( LPCWSTR lpLibFileName ); #ifdef UNICODE #define LoadLibrary LoadLibraryW #else #define LoadLibrary LoadLibraryA #endif // !UNICODE DWORD WINAPI GetModuleFileNameA( HINSTANCE hModule, LPSTR lpFilename, DWORD nSize ); DWORD WINAPI GetModuleFileNameW( HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize ); #ifdef UNICODE #define GetModuleFileName GetModuleFileNameW #else #define GetModuleFileName GetModuleFileNameA #endif // !UNICODE HMODULE WINAPI GetModuleHandleA( LPCSTR lpModuleName ); HMODULE WINAPI GetModuleHandleW( LPCWSTR lpModuleName ); #ifdef UNICODE #define GetModuleHandle GetModuleHandleW #else #define GetModuleHandle GetModuleHandleA #endif // !UNICODE BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPCSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); BOOL WINAPI CreateProcessW( LPCWSTR lpApplicationName, LPCWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPWSTR lpCurrentDirectory, LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation ); #ifdef UNICODE #define CreateProcess CreateProcessW #else #define CreateProcess CreateProcessA #endif // !UNICODE VOID WINAPI FatalAppExitA( UINT uAction, LPCSTR lpMessageText ); VOID WINAPI FatalAppExitW( UINT uAction, LPCWSTR lpMessageText ); #ifdef UNICODE #define FatalAppExit FatalAppExitW #else #define FatalAppExit FatalAppExitA #endif // !UNICODE VOID WINAPI GetStartupInfoA( LPSTARTUPINFOA lpStartupInfo ); VOID WINAPI GetStartupInfoW( LPSTARTUPINFOW lpStartupInfo ); #ifdef UNICODE #define GetStartupInfo GetStartupInfoW #else #define GetStartupInfo GetStartupInfoA #endif // !UNICODE LPSTR WINAPI GetCommandLineA( VOID ); LPWSTR WINAPI GetCommandLineW( VOID ); #ifdef UNICODE #define GetCommandLine GetCommandLineW #else #define GetCommandLine GetCommandLineA #endif // !UNICODE DWORD WINAPI GetEnvironmentVariableA( LPSTR lpName, LPSTR lpBuffer, DWORD nSize ); DWORD WINAPI GetEnvironmentVariableW( LPWSTR lpName, LPWSTR lpBuffer, DWORD nSize ); #ifdef UNICODE #define GetEnvironmentVariable GetEnvironmentVariableW #else #define GetEnvironmentVariable GetEnvironmentVariableA #endif // !UNICODE BOOL WINAPI SetEnvironmentVariableA( LPSTR lpName, LPSTR lpValue ); BOOL WINAPI SetEnvironmentVariableW( LPWSTR lpName, LPWSTR lpValue ); #ifdef UNICODE #define SetEnvironmentVariable SetEnvironmentVariableW #else #define SetEnvironmentVariable SetEnvironmentVariableA #endif // !UNICODE DWORD WINAPI ExpandEnvironmentStringsA( LPCSTR lpSrc, LPSTR lpDst, DWORD nSize ); DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize ); #ifdef UNICODE #define ExpandEnvironmentStrings ExpandEnvironmentStringsW #else #define ExpandEnvironmentStrings ExpandEnvironmentStringsA #endif // !UNICODE VOID WINAPI OutputDebugStringA( LPCSTR lpOutputString ); VOID WINAPI OutputDebugStringW( LPCWSTR lpOutputString ); #ifdef UNICODE #define OutputDebugString OutputDebugStringW #else #define OutputDebugString OutputDebugStringA #endif // !UNICODE HRSRC WINAPI FindResourceA( HINSTANCE hModule, LPCSTR lpName, LPCSTR lpType ); HRSRC WINAPI FindResourceW( HINSTANCE hModule, LPCWSTR lpName, LPCWSTR lpType ); #ifdef UNICODE #define FindResource FindResourceW #else #define FindResource FindResourceA #endif // !UNICODE HRSRC WINAPI FindResourceExA( HINSTANCE hModule, LPCSTR lpType, LPCSTR lpName, WORD wLanguage ); HRSRC WINAPI FindResourceExW( HINSTANCE hModule, LPCWSTR lpType, LPCWSTR lpName, WORD wLanguage ); #ifdef UNICODE #define FindResourceEx FindResourceExW #else #define FindResourceEx FindResourceExA #endif // !UNICODE #ifdef STRICT typedef BOOL (CALLBACK* ENUMRESTYPEPROC)(HANDLE hModule, LPTSTR lpType, LONG lParam); typedef BOOL (CALLBACK* ENUMRESNAMEPROC)(HANDLE hModule, LPCTSTR lpType, LPTSTR lpName, LONG lParam); typedef BOOL (CALLBACK* ENUMRESLANGPROC)(HANDLE hModule, LPCTSTR lpType, LPCTSTR lpName, WORD wLanguage, LONG lParam); #else typedef FARPROC ENUMRESTYPEPROC; typedef FARPROC ENUMRESNAMEPROC; typedef FARPROC ENUMRESLANGPROC; #endif BOOL WINAPI EnumResourceTypesA( HANDLE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); BOOL WINAPI EnumResourceTypesW( HANDLE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceTypes EnumResourceTypesW #else #define EnumResourceTypes EnumResourceTypesA #endif // !UNICODE BOOL WINAPI EnumResourceNamesA( HANDLE hModule, LPCSTR lpType, ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); BOOL WINAPI EnumResourceNamesW( HANDLE hModule, LPCWSTR lpType, ENUMRESNAMEPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceNames EnumResourceNamesW #else #define EnumResourceNames EnumResourceNamesA #endif // !UNICODE BOOL WINAPI EnumResourceLanguagesA( HANDLE hModule, LPCSTR lpType, LPCSTR lpName, ENUMRESLANGPROC lpEnumFunc, LONG lParam ); BOOL WINAPI EnumResourceLanguagesW( HANDLE hModule, LPCWSTR lpType, LPCWSTR lpName, ENUMRESLANGPROC lpEnumFunc, LONG lParam ); #ifdef UNICODE #define EnumResourceLanguages EnumResourceLanguagesW #else #define EnumResourceLanguages EnumResourceLanguagesA #endif // !UNICODE HANDLE WINAPI BeginUpdateResourceA( LPSTR pFileName ); HANDLE WINAPI BeginUpdateResourceW( LPWSTR pFileName ); #ifdef UNICODE #define BeginUpdateResource BeginUpdateResourceW #else #define BeginUpdateResource BeginUpdateResourceA #endif // !UNICODE BOOL WINAPI UpdateResourceA( HANDLE hUpdate, LPSTR lpType, LPSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData ); BOOL WINAPI UpdateResourceW( HANDLE hUpdate, LPWSTR lpType, LPWSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData ); #ifdef UNICODE #define UpdateResource UpdateResourceW #else #define UpdateResource UpdateResourceA #endif // !UNICODE BOOL WINAPI EndUpdateResourceA( HANDLE hUpdate, BOOL fDiscard ); BOOL WINAPI EndUpdateResourceW( HANDLE hUpdate, BOOL fDiscard ); #ifdef UNICODE #define EndUpdateResource EndUpdateResourceW #else #define EndUpdateResource EndUpdateResourceA #endif // !UNICODE ATOM WINAPI GlobalAddAtomA( LPCSTR lpString ); ATOM WINAPI GlobalAddAtomW( LPCWSTR lpString ); #ifdef UNICODE #define GlobalAddAtom GlobalAddAtomW #else #define GlobalAddAtom GlobalAddAtomA #endif // !UNICODE ATOM WINAPI GlobalFindAtomA( LPCSTR lpString ); ATOM WINAPI GlobalFindAtomW( LPCWSTR lpString ); #ifdef UNICODE #define GlobalFindAtom GlobalFindAtomW #else #define GlobalFindAtom GlobalFindAtomA #endif // !UNICODE UINT WINAPI GlobalGetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize ); UINT WINAPI GlobalGetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize ); #ifdef UNICODE #define GlobalGetAtomName GlobalGetAtomNameW #else #define GlobalGetAtomName GlobalGetAtomNameA #endif // !UNICODE ATOM WINAPI AddAtomA( LPCSTR lpString ); ATOM WINAPI AddAtomW( LPCWSTR lpString ); #ifdef UNICODE #define AddAtom AddAtomW #else #define AddAtom AddAtomA #endif // !UNICODE ATOM WINAPI FindAtomA( LPCSTR lpString ); ATOM WINAPI FindAtomW( LPCWSTR lpString ); #ifdef UNICODE #define FindAtom FindAtomW #else #define FindAtom FindAtomA #endif // !UNICODE UINT WINAPI GetAtomNameA( ATOM nAtom, LPSTR lpBuffer, int nSize ); UINT WINAPI GetAtomNameW( ATOM nAtom, LPWSTR lpBuffer, int nSize ); #ifdef UNICODE #define GetAtomName GetAtomNameW #else #define GetAtomName GetAtomNameA #endif // !UNICODE UINT WINAPI GetProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, DWORD nDefault ); UINT WINAPI GetProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, DWORD nDefault ); #ifdef UNICODE #define GetProfileInt GetProfileIntW #else #define GetProfileInt GetProfileIntA #endif // !UNICODE DWORD WINAPI GetProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize ); DWORD WINAPI GetProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE #define GetProfileString GetProfileStringW #else #define GetProfileString GetProfileStringA #endif // !UNICODE BOOL WINAPI WriteProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString ); BOOL WINAPI WriteProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString ); #ifdef UNICODE #define WriteProfileString WriteProfileStringW #else #define WriteProfileString WriteProfileStringA #endif // !UNICODE DWORD WINAPI GetProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize ); DWORD WINAPI GetProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize ); #ifdef UNICODE #define GetProfileSection GetProfileSectionW #else #define GetProfileSection GetProfileSectionA #endif // !UNICODE BOOL WINAPI WriteProfileSectionA( LPCSTR lpAppName, LPCSTR lpString ); BOOL WINAPI WriteProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString ); #ifdef UNICODE #define WriteProfileSection WriteProfileSectionW #else #define WriteProfileSection WriteProfileSectionA #endif // !UNICODE UINT WINAPI GetPrivateProfileIntA( LPCSTR lpAppName, LPCSTR lpKeyName, DWORD nDefault, LPCSTR lpFileName ); UINT WINAPI GetPrivateProfileIntW( LPCWSTR lpAppName, LPCWSTR lpKeyName, DWORD nDefault, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileInt GetPrivateProfileIntW #else #define GetPrivateProfileInt GetPrivateProfileIntA #endif // !UNICODE DWORD WINAPI GetPrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName ); 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 BOOL WINAPI WritePrivateProfileStringA( LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpString, LPCSTR lpFileName ); BOOL WINAPI WritePrivateProfileStringW( LPCWSTR lpAppName, LPCWSTR lpKeyName, LPCWSTR lpString, LPCWSTR lpFileName ); #ifdef UNICODE #define WritePrivateProfileString WritePrivateProfileStringW #else #define WritePrivateProfileString WritePrivateProfileStringA #endif // !UNICODE DWORD WINAPI GetPrivateProfileSectionA( LPCSTR lpAppName, LPSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName ); DWORD WINAPI GetPrivateProfileSectionW( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize, LPCWSTR lpFileName ); #ifdef UNICODE #define GetPrivateProfileSection GetPrivateProfileSectionW #else #define GetPrivateProfileSection GetPrivateProfileSectionA #endif // !UNICODE BOOL WINAPI WritePrivateProfileSectionA( LPCSTR lpAppName, LPCSTR lpString, LPCSTR lpFileName ); BOOL WINAPI WritePrivateProfileSectionW( LPCWSTR lpAppName, LPCWSTR lpString, LPCWSTR lpFileName ); #ifdef UNICODE #define WritePrivateProfileSection WritePrivateProfileSectionW #else #define WritePrivateProfileSection WritePrivateProfileSectionA #endif // !UNICODE UINT WINAPI GetDriveTypeA( LPSTR lpRootPathName ); UINT WINAPI GetDriveTypeW( LPWSTR lpRootPathName ); #ifdef UNICODE #define GetDriveType GetDriveTypeW #else #define GetDriveType GetDriveTypeA #endif // !UNICODE UINT WINAPI GetSystemDirectoryA( LPSTR lpBuffer, UINT uSize ); UINT WINAPI GetSystemDirectoryW( LPWSTR lpBuffer, UINT uSize ); #ifdef UNICODE #define GetSystemDirectory GetSystemDirectoryW #else #define GetSystemDirectory GetSystemDirectoryA #endif // !UNICODE DWORD WINAPI GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD WINAPI GetTempPathW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetTempPath GetTempPathW #else #define GetTempPath GetTempPathA #endif // !UNICODE UINT WINAPI GetTempFileNameA( LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName ); UINT WINAPI GetTempFileNameW( LPCWSTR lpPathName, LPCWSTR lpPrefixString, UINT uUnique, LPWSTR lpTempFileName ); #ifdef UNICODE #define GetTempFileName GetTempFileNameW #else #define GetTempFileName GetTempFileNameA #endif // !UNICODE UINT WINAPI GetWindowsDirectoryA( LPSTR lpBuffer, UINT uSize ); UINT WINAPI GetWindowsDirectoryW( LPWSTR lpBuffer, UINT uSize ); #ifdef UNICODE #define GetWindowsDirectory GetWindowsDirectoryW #else #define GetWindowsDirectory GetWindowsDirectoryA #endif // !UNICODE BOOL WINAPI SetCurrentDirectoryA( LPSTR lpPathName ); BOOL WINAPI SetCurrentDirectoryW( LPWSTR lpPathName ); #ifdef UNICODE #define SetCurrentDirectory SetCurrentDirectoryW #else #define SetCurrentDirectory SetCurrentDirectoryA #endif // !UNICODE DWORD WINAPI GetCurrentDirectoryA( DWORD nBufferLength, LPSTR lpBuffer ); DWORD WINAPI GetCurrentDirectoryW( DWORD nBufferLength, LPWSTR lpBuffer ); #ifdef UNICODE #define GetCurrentDirectory GetCurrentDirectoryW #else #define GetCurrentDirectory GetCurrentDirectoryA #endif // !UNICODE BOOL WINAPI GetDiskFreeSpaceA( LPSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); BOOL WINAPI GetDiskFreeSpaceW( LPWSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters ); #ifdef UNICODE #define GetDiskFreeSpace GetDiskFreeSpaceW #else #define GetDiskFreeSpace GetDiskFreeSpaceA #endif // !UNICODE BOOL WINAPI CreateDirectoryA( LPSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); BOOL WINAPI CreateDirectoryW( LPWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); #ifdef UNICODE #define CreateDirectory CreateDirectoryW #else #define CreateDirectory CreateDirectoryA #endif // !UNICODE BOOL WINAPI RemoveDirectoryA( LPSTR lpPathName ); BOOL WINAPI RemoveDirectoryW( LPWSTR lpPathName ); #ifdef UNICODE #define RemoveDirectory RemoveDirectoryW #else #define RemoveDirectory RemoveDirectoryA #endif // !UNICODE DWORD WINAPI GetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); DWORD WINAPI GetFullPathNameW( LPCWSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR *lpFilePart ); #ifdef UNICODE #define GetFullPathName GetFullPathNameW #else #define GetFullPathName GetFullPathNameA #endif // !UNICODE #define EXPAND_LOCAL_DRIVES HANDLE WINAPI CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ); 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 BOOL WINAPI SetFileAttributesA( LPSTR lpFileName, DWORD dwFileAttributes ); BOOL WINAPI SetFileAttributesW( LPWSTR lpFileName, DWORD dwFileAttributes ); #ifdef UNICODE #define SetFileAttributes SetFileAttributesW #else #define SetFileAttributes SetFileAttributesA #endif // !UNICODE DWORD WINAPI GetFileAttributesA( LPSTR lpFileName ); DWORD WINAPI GetFileAttributesW( LPWSTR lpFileName ); #ifdef UNICODE #define GetFileAttributes GetFileAttributesW #else #define GetFileAttributes GetFileAttributesA #endif // !UNICODE BOOL WINAPI DeleteFileA( LPSTR lpFileName ); BOOL WINAPI DeleteFileW( LPWSTR lpFileName ); #ifdef UNICODE #define DeleteFile DeleteFileW #else #define DeleteFile DeleteFileA #endif // !UNICODE HANDLE WINAPI FindFirstFileA( LPSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData ); HANDLE WINAPI FindFirstFileW( LPWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE #define FindFirstFile FindFirstFileW #else #define FindFirstFile FindFirstFileA #endif // !UNICODE BOOL WINAPI FindNextFileA( HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData ); BOOL WINAPI FindNextFileW( HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData ); #ifdef UNICODE #define FindNextFile FindNextFileW #else #define FindNextFile FindNextFileA #endif // !UNICODE DWORD WINAPI SearchPathA( LPCSTR lpPath, LPCSTR lpFileName, LPCSTR lpExtension, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ); 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 BOOL WINAPI CopyFileA( LPSTR lpExistingFileName, LPSTR lpNewFileName, BOOL bFailIfExists ); BOOL WINAPI CopyFileW( LPWSTR lpExistingFileName, LPWSTR lpNewFileName, BOOL bFailIfExists ); #ifdef UNICODE #define CopyFile CopyFileW #else #define CopyFile CopyFileA #endif // !UNICODE BOOL WINAPI MoveFileA( LPSTR lpExistingFileName, LPSTR lpNewFileName ); BOOL WINAPI MoveFileW( LPWSTR lpExistingFileName, LPWSTR lpNewFileName ); #ifdef UNICODE #define MoveFile MoveFileW #else #define MoveFile MoveFileA #endif // !UNICODE HANDLE WINAPI CreateNamedPipeA( LPSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes ); HANDLE WINAPI CreateNamedPipeW( LPWSTR 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 BOOL WINAPI GetNamedPipeHandleStateA( HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout, LPSTR lpUserName, DWORD nMaxUserNameSize ); 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 BOOL WINAPI CallNamedPipeA( LPSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut ); BOOL WINAPI CallNamedPipeW( LPWSTR lpNamedPipeName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead, DWORD nTimeOut ); #ifdef UNICODE #define CallNamedPipe CallNamedPipeW #else #define CallNamedPipe CallNamedPipeA #endif // !UNICODE BOOL WINAPI WaitNamedPipeA( LPSTR lpNamedPipeName, DWORD nTimeOut ); BOOL WINAPI WaitNamedPipeW( LPWSTR lpNamedPipeName, DWORD nTimeOut ); #ifdef UNICODE #define WaitNamedPipe WaitNamedPipeW #else #define WaitNamedPipe WaitNamedPipeA #endif // !UNICODE BOOL WINAPI GetVolumeInformationA( LPSTR lpRootPathName, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize, LPDWORD lpVolumeSerialNumber, LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize ); BOOL WINAPI GetVolumeInformationW( LPWSTR 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 // // Event logging APIs // BOOL WINAPI ClearEventLogA ( HANDLE hEventLog, LPSTR lpBackupFileName ); BOOL WINAPI ClearEventLogW ( HANDLE hEventLog, LPWSTR lpBackupFileName ); #ifdef UNICODE #define ClearEventLog ClearEventLogW #else #define ClearEventLog ClearEventLogA #endif // !UNICODE BOOL WINAPI BackupEventLogA ( HANDLE hEventLog, LPSTR lpBackupFileName ); BOOL WINAPI BackupEventLogW ( HANDLE hEventLog, LPWSTR lpBackupFileName ); #ifdef UNICODE #define BackupEventLog BackupEventLogW #else #define BackupEventLog BackupEventLogA #endif // !UNICODE BOOL WINAPI CloseEventLog ( HANDLE hEventLog ); BOOL WINAPI DeregisterEventSource ( HANDLE hEventLog ); BOOL WINAPI GetNumberOfEventLogRecords ( HANDLE hEventLog, PDWORD NumberOfRecords ); BOOL WINAPI GetOldestEventLogRecord ( HANDLE hEventLog, PDWORD OldestRecord ); HANDLE WINAPI OpenEventLogA ( LPSTR lpUNCServerName, LPSTR lpSourceName ); HANDLE WINAPI OpenEventLogW ( LPWSTR lpUNCServerName, LPWSTR lpSourceName ); #ifdef UNICODE #define OpenEventLog OpenEventLogW #else #define OpenEventLog OpenEventLogA #endif // !UNICODE HANDLE WINAPI RegisterEventSourceA ( LPSTR lpUNCServerName, LPSTR lpSourceName ); HANDLE WINAPI RegisterEventSourceW ( LPWSTR lpUNCServerName, LPWSTR lpSourceName ); #ifdef UNICODE #define RegisterEventSource RegisterEventSourceW #else #define RegisterEventSource RegisterEventSourceA #endif // !UNICODE HANDLE WINAPI OpenBackupEventLogA ( LPSTR lpUNCServerName, LPSTR lpFileName ); HANDLE WINAPI OpenBackupEventLogW ( LPWSTR lpUNCServerName, LPWSTR lpFileName ); #ifdef UNICODE #define OpenBackupEventLog OpenBackupEventLogW #else #define OpenBackupEventLog OpenBackupEventLogA #endif // !UNICODE BOOL WINAPI ReadEventLogA ( HANDLE hEventLog, DWORD dwReadFlags, DWORD dwRecordOffset, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, DWORD *pnBytesRead, DWORD *pnMinNumberOfBytesNeeded ); 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 BOOL WINAPI ReportEventA ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPSTR *lpStrings, LPVOID lpRawData ); BOOL WINAPI ReportEventW ( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPWSTR *lpStrings, LPVOID lpRawData ); #ifdef UNICODE #define ReportEvent ReportEventW #else #define ReportEvent ReportEventA #endif // !UNICODE // // // Security APIs // BOOL WINAPI DuplicateToken( HANDLE ExistingTokenHandle, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, PHANDLE DuplicateTokenHandle ); BOOL WINAPI GetKernelObjectSecurity ( HANDLE Handle, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); BOOL WINAPI ImpersonateNamedPipeClient( HANDLE hNamedPipe ); BOOL WINAPI ImpersonateSelf( SECURITY_IMPERSONATION_LEVEL ImpersonationLevel ); BOOL WINAPI RevertToSelf ( VOID ); BOOL WINAPI AccessCheck ( PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, PPRIVILEGE_SET PrivilegeSet, LPDWORD PrivilegeSetLength, LPDWORD GrantedAccess, LPBOOL AccessStatus ); BOOL WINAPI OpenProcessToken ( HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle ); BOOL WINAPI OpenThreadToken ( HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, PHANDLE TokenHandle ); BOOL WINAPI GetTokenInformation ( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength ); BOOL WINAPI SetTokenInformation ( HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength ); BOOL WINAPI AdjustTokenPrivileges ( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength ); BOOL WINAPI AdjustTokenGroups ( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState, DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength ); BOOL WINAPI PrivilegeCheck ( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult ); BOOL WINAPI AccessCheckAndAuditAlarmA ( LPSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose ); BOOL WINAPI AccessCheckAndAuditAlarmW ( LPWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess, PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess, LPBOOL AccessStatus, LPBOOL pfGenerateOnClose ); #ifdef UNICODE #define AccessCheckAndAuditAlarm AccessCheckAndAuditAlarmW #else #define AccessCheckAndAuditAlarm AccessCheckAndAuditAlarmA #endif // !UNICODE BOOL WINAPI ObjectOpenAuditAlarmA ( LPSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName, LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose ); BOOL WINAPI ObjectOpenAuditAlarmW ( LPWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName, LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess, DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted, LPBOOL GenerateOnClose ); #ifdef UNICODE #define ObjectOpenAuditAlarm ObjectOpenAuditAlarmW #else #define ObjectOpenAuditAlarm ObjectOpenAuditAlarmA #endif // !UNICODE BOOL WINAPI ObjectPrivilegeAuditAlarmA ( LPSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); BOOL WINAPI ObjectPrivilegeAuditAlarmW ( LPWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken, DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); #ifdef UNICODE #define ObjectPrivilegeAuditAlarm ObjectPrivilegeAuditAlarmW #else #define ObjectPrivilegeAuditAlarm ObjectPrivilegeAuditAlarmA #endif // !UNICODE BOOL WINAPI ObjectCloseAuditAlarmA ( LPSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); BOOL WINAPI ObjectCloseAuditAlarmW ( LPWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose ); #ifdef UNICODE #define ObjectCloseAuditAlarm ObjectCloseAuditAlarmW #else #define ObjectCloseAuditAlarm ObjectCloseAuditAlarmA #endif // !UNICODE BOOL WINAPI PrivilegedServiceAuditAlarmA ( LPSTR SubsystemName, LPSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); BOOL WINAPI PrivilegedServiceAuditAlarmW ( LPWSTR SubsystemName, LPWSTR ServiceName, HANDLE ClientToken, PPRIVILEGE_SET Privileges, BOOL AccessGranted ); #ifdef UNICODE #define PrivilegedServiceAuditAlarm PrivilegedServiceAuditAlarmW #else #define PrivilegedServiceAuditAlarm PrivilegedServiceAuditAlarmA #endif // !UNICODE BOOL WINAPI IsValidSid ( PSID pSid ); BOOL WINAPI EqualSid ( PSID pSid1, PSID pSid2 ); BOOL WINAPI EqualPrefixSid ( PSID pSid1, PSID pSid2 ); DWORD WINAPI GetSidLengthRequired ( UCHAR nSubAuthorityCount ); BOOL WINAPI AllocateAndInitializeSid ( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid ); PVOID WINAPI FreeSid( PSID pSid ); BOOL WINAPI InitializeSid ( PSID Sid, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount ); PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority ( PSID pSid ); PDWORD WINAPI GetSidSubAuthority ( PSID pSid, DWORD nSubAuthority ); PUCHAR WINAPI GetSidSubAuthorityCount ( PSID pSid ); DWORD WINAPI GetLengthSid ( PSID pSid ); BOOL WINAPI CopySid ( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid ); BOOL WINAPI AreAllAccessesGranted ( DWORD GrantedAccess, DWORD DesiredAccess ); BOOL WINAPI AreAnyAccessesGranted ( DWORD GrantedAccess, DWORD DesiredAccess ); VOID WINAPI MapGenericMask ( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping ); BOOL WINAPI IsValidAcl ( PACL pAcl ); BOOL WINAPI InitializeAcl ( PACL pAcl, DWORD nAclLength, DWORD dwAclRevision ); BOOL WINAPI GetAclInformation ( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass ); BOOL WINAPI SetAclInformation ( PACL pAcl, LPVOID pAclInformation, DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass ); BOOL WINAPI AddAce ( PACL pAcl, DWORD dwAceRevision, DWORD dwStartingAceIndex, LPVOID pAceList, DWORD nAceListLength ); BOOL WINAPI DeleteAce ( PACL pAcl, DWORD dwAceIndex ); BOOL WINAPI GetAce ( PACL pAcl, DWORD dwAceIndex, LPVOID *pAce ); BOOL WINAPI AddAccessAllowedAce ( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid ); BOOL WINAPI AddAccessDeniedAce ( PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid ); BOOL WINAPI AddAuditAccessAce( PACL pAcl, DWORD dwAceRevision, DWORD dwAccessMask, PSID pSid, BOOL bAuditSuccess, BOOL bAuditFailure ); BOOL WINAPI FindFirstFreeAce ( PACL pAcl, LPVOID *pAce ); BOOL WINAPI InitializeSecurityDescriptor ( PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision ); BOOL WINAPI IsValidSecurityDescriptor ( PSECURITY_DESCRIPTOR pSecurityDescriptor ); DWORD WINAPI GetSecurityDescriptorLength ( PSECURITY_DESCRIPTOR pSecurityDescriptor ); BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision ); BOOL WINAPI SetSecurityDescriptorDacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted ); BOOL WINAPI GetSecurityDescriptorDacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent, PACL *pDacl, LPBOOL lpbDaclDefaulted ); BOOL WINAPI SetSecurityDescriptorSacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent, PACL pSacl, BOOL bSaclDefaulted ); BOOL WINAPI GetSecurityDescriptorSacl ( PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent, PACL *pSacl, LPBOOL lpbSaclDefaulted ); BOOL WINAPI SetSecurityDescriptorOwner ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted ); BOOL WINAPI GetSecurityDescriptorOwner ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pOwner, LPBOOL lpbOwnerDefaulted ); BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted ); BOOL WINAPI GetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pGroup, LPBOOL lpbGroupDefaulted ); BOOL WINAPI CreatePrivateObjectSecurity ( PSECURITY_DESCRIPTOR ParentDescriptor, PSECURITY_DESCRIPTOR CreatorDescriptor, PSECURITY_DESCRIPTOR * NewDescriptor, BOOL IsDirectoryObject, HANDLE Token, PGENERIC_MAPPING GenericMapping ); BOOL WINAPI SetPrivateObjectSecurity ( SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ModificationDescriptor, PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, PGENERIC_MAPPING GenericMapping, HANDLE Token ); BOOL WINAPI GetPrivateObjectSecurity ( PSECURITY_DESCRIPTOR ObjectDescriptor, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR ResultantDescriptor, DWORD DescriptorLength, PDWORD ReturnLength ); BOOL WINAPI DestroyPrivateObjectSecurity ( PSECURITY_DESCRIPTOR * ObjectDescriptor ); BOOL WINAPI MakeSelfRelativeSD ( PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength ); BOOL WINAPI MakeAbsoluteSD ( PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl, LPDWORD lpdwDaclSize, PACL pSacl, LPDWORD lpdwSaclSize, PSID pOwner, LPDWORD lpdwOwnerSize, PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize ); BOOL WINAPI SetFileSecurityA ( LPSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor ); BOOL WINAPI SetFileSecurityW ( LPWSTR lpFileName, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor ); #ifdef UNICODE #define SetFileSecurity SetFileSecurityW #else #define SetFileSecurity SetFileSecurityA #endif // !UNICODE BOOL WINAPI GetFileSecurityA ( LPSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); BOOL WINAPI GetFileSecurityW ( LPWSTR lpFileName, SECURITY_INFORMATION RequestedInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD nLength, LPDWORD lpnLengthNeeded ); #ifdef UNICODE #define GetFileSecurity GetFileSecurityW #else #define GetFileSecurity GetFileSecurityA #endif // !UNICODE BOOL WINAPI SetKernelObjectSecurity ( HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor ); HANDLE WINAPI FindFirstChangeNotificationA( LPSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter ); HANDLE WINAPI FindFirstChangeNotificationW( LPWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter ); #ifdef UNICODE #define FindFirstChangeNotification FindFirstChangeNotificationW #else #define FindFirstChangeNotification FindFirstChangeNotificationA #endif // !UNICODE BOOL WINAPI FindNextChangeNotification( HANDLE hChangeHandle ); BOOL WINAPI FindCloseChangeNotification( HANDLE hChangeHandle ); BOOL WINAPI VirtualLock( LPVOID lpAddress, DWORD dwSize ); BOOL WINAPI VirtualUnlock( LPVOID lpAddress, DWORD dwSize ); LPVOID WINAPI MapViewOfFileEx( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap, LPVOID lpBaseAddress ); BOOL WINAPI SetPriorityClass( HANDLE hProcess, DWORD dwPriorityClass ); DWORD WINAPI GetPriorityClass( HANDLE hProcess ); BOOL WINAPI IsBadReadPtr( CONST VOID *lp, UINT ucb ); BOOL WINAPI IsBadWritePtr( LPVOID lp, UINT ucb ); BOOL WINAPI IsBadHugeReadPtr( CONST VOID *lp, UINT ucb ); BOOL WINAPI IsBadHugeWritePtr( LPVOID lp, UINT ucb ); BOOL WINAPI IsBadCodePtr( FARPROC lpfn ); BOOL WINAPI IsBadStringPtrA( LPCSTR lpsz, UINT ucchMax ); BOOL WINAPI IsBadStringPtrW( LPCWSTR lpsz, UINT ucchMax ); #ifdef UNICODE #define IsBadStringPtr IsBadStringPtrW #else #define IsBadStringPtr IsBadStringPtrA #endif // !UNICODE BOOL WINAPI LookupAccountSidA( LPSTR lpSystemName, PSID Sid, LPSTR Name, LPDWORD cbName, LPSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); BOOL WINAPI LookupAccountSidW( LPWSTR lpSystemName, PSID Sid, LPWSTR Name, LPDWORD cbName, LPWSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); #ifdef UNICODE #define LookupAccountSid LookupAccountSidW #else #define LookupAccountSid LookupAccountSidA #endif // !UNICODE BOOL WINAPI LookupAccountNameA( LPSTR lpSystemName, LPSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); BOOL WINAPI LookupAccountNameW( LPWSTR lpSystemName, LPWSTR lpAccountName, PSID Sid, LPDWORD cbSid, LPWSTR ReferencedDomainName, LPDWORD cbReferencedDomainName, PSID_NAME_USE peUse ); #ifdef UNICODE #define LookupAccountName LookupAccountNameW #else #define LookupAccountName LookupAccountNameA #endif // !UNICODE BOOL WINAPI LookupPrivilegeValueA( LPSTR lpSystemName, LPSTR lpName, PLUID lpLuid ); BOOL WINAPI LookupPrivilegeValueW( LPWSTR lpSystemName, LPWSTR lpName, PLUID lpLuid ); #ifdef UNICODE #define LookupPrivilegeValue LookupPrivilegeValueW #else #define LookupPrivilegeValue LookupPrivilegeValueA #endif // !UNICODE BOOL WINAPI LookupPrivilegeNameA( LPSTR lpSystemName, PLUID lpLuid, LPSTR lpName, LPDWORD cbName ); BOOL WINAPI LookupPrivilegeNameW( LPWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName, LPDWORD cbName ); #ifdef UNICODE #define LookupPrivilegeName LookupPrivilegeNameW #else #define LookupPrivilegeName LookupPrivilegeNameA #endif // !UNICODE BOOL WINAPI LookupPrivilegeDisplayNameA( LPSTR lpSystemName, LPSTR lpName, LPSTR lpDisplayName, LPDWORD cbDisplayName, LPDWORD lpLanguageId ); BOOL WINAPI LookupPrivilegeDisplayNameW( LPWSTR lpSystemName, LPWSTR lpName, LPWSTR lpDisplayName, LPDWORD cbDisplayName, LPDWORD lpLanguageId ); #ifdef UNICODE #define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameW #else #define LookupPrivilegeDisplayName LookupPrivilegeDisplayNameA #endif // !UNICODE BOOL WINAPI AllocateLocallyUniqueId( PLUID Luid ); BOOL WINAPI BuildCommDCBA( LPSTR lpDef, LPDCB lpDCB ); BOOL WINAPI BuildCommDCBW( LPWSTR lpDef, LPDCB lpDCB ); #ifdef UNICODE #define BuildCommDCB BuildCommDCBW #else #define BuildCommDCB BuildCommDCBA #endif // !UNICODE #define MAX_COMPUTERNAME_LENGTH 80 BOOL WINAPI GetComputerNameA ( LPSTR lpBuffer, LPDWORD nSize ); BOOL WINAPI GetComputerNameW ( LPWSTR lpBuffer, LPDWORD nSize ); #ifdef UNICODE #define GetComputerName GetComputerNameW #else #define GetComputerName GetComputerNameA #endif // !UNICODE BOOL WINAPI SetComputerNameA ( LPSTR lpComputerName ); BOOL WINAPI SetComputerNameW ( LPWSTR lpComputerName ); #ifdef UNICODE #define SetComputerName SetComputerNameW #else #define SetComputerName SetComputerNameA #endif // !UNICODE BOOL WINAPI GetUserNameA ( LPSTR lpBuffer, LPDWORD nSize ); BOOL WINAPI GetUserNameW ( LPWSTR lpBuffer, LPDWORD nSize ); #ifdef UNICODE #define GetUserName GetUserNameW #else #define GetUserName GetUserNameA #endif // !UNICODE // // Performance counter API's // BOOL WINAPI QueryPerformanceCounter( LARGE_INTEGER *lpPerformanceCount ); BOOL WINAPI QueryPerformanceFrequency( LARGE_INTEGER *lpFrequency ); // DOS and OS/2 Compatible Error Code definitions returned by the Win32 Base // API functions. // #include <winerror.h> /* Abnormal termination codes */ #define TC_NORMAL 0 #define TC_HARDERR 1 #define TC_GP_TRAP 2 #define TC_SIGNAL 3 #endif // _WINBASE_

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.