Context Navigation

source: trunk/include/HandleManager.h@ 5004

Visit:

Last change on this file since 5004 was 4285, checked in by hugh, 25 years ago
Implemented Serial APIs
File size: 23.1 KB

Rev	Line
[4285]	1	/* $Id: HandleManager.h,v 1.24 2000-09-20 21:32:56 hugh Exp $ */
[262]	2
	3	/*
	4	* Project Odin Software License can be found in LICENSE.TXT
	5	* Win32 Unified Handle Manager for OS/2
	6	* 1998/02/11 PH Patrick Haller (haller@zebra.fh-weingarten.de)
	7	*
	8	* @(#) HandleManager.Cpp 1.0.0 1998/02/11 PH start
	9	*/
	10
	11	#ifndef _HANDLEMANAGER_H_
	12	#define _HANDLEMANAGER_H_
	13
	14
	15	/*****************************************************************************
	16	* Remark *
	17	*****************************************************************************
	18
	19	1998/02/11 PH The interface to the handle manager is twofold:
	20	a) HMxxx routines to be called from the "top" from the
	21	KERNEL32 stubs
	22	b) the HMDeviceHandler class is actually a workaround for
	23	the device driver that would handle the requests on Win32.
	24	To implement a new pseudo-device, one has create a new
	25	HMDeviceHandler class and link it into the table in the
	26	HANDLEMANAGER.CPP file.
	27	*/
	28
	29
	30	/*****************************************************************************
	31	* Includes *
	32	*****************************************************************************/
	33
[781]	34	#ifdef _OS2WIN_H
	35	#include <winos2def.h>
	36	#endif
	37
[1857]	38
[776]	39	//LPSECURITY_ATTRIBUTES
	40
	41
[262]	42	/*****************************************************************************
	43	* Defines & Macros *
	44	*****************************************************************************/
	45
	46	/* 1998/02/12 PH Correction of os2win.h */
	47	#undef FILE_TYPE_UNKNOWN
	48	#define FILE_TYPE_UNKNOWN 0x0000
	49
	50	#undef FILE_TYPE_DISK
	51	#define FILE_TYPE_DISK 0x0001
	52
	53	#undef FILE_TYPE_CHAR
	54	#define FILE_TYPE_CHAR 0x0002
	55
	56	#undef FILE_TYPE_PIPE
	57	#define FILE_TYPE_PIPE 0x0003
	58
	59	#undef FILE_TYPE_REMOTE
	60	#define FILE_TYPE_REMOTE 0x8000
	61
	62	#ifndef INVALID_HANDLE_ERROR
	63	#define INVALID_HANDLE_ERROR (-1)
	64	#endif
	65
	66
	67	/*****************************************************************************
	68	* Structures *
	69	*****************************************************************************/
	70
	71
	72	/*****************************************************************************
	73	* Prototypes *
	74	*****************************************************************************/
	75
	76	DWORD HMInitialize(void); /* initialize the HandleManager */
	77
	78	DWORD HMTerminate(void); /* terminate the HandleManager */
	79
	80
	81	/* handle manager version of GetStdHandle, Open32 can't really help us here */
	82	HANDLE HMGetStdHandle(DWORD nStdHandle);
	83
	84	/* handle manager version of GetStdHandle, Open32 can't really help us here */
	85	BOOL HMSetStdHandle(DWORD nStdHandle,
	86	HANDLE hHandle);
	87
	88
	89	/*****************************************************************************/
	90	/* handle translation buffer management */
	91	/* */
	92	/* Since some Win32 applications rely (!) on 16-bit handles, we've got to do */
	93	/* 32-bit to 16-bit and vs vsa translation here. */
	94	/* Filehandle-based functions should be routed via the handlemanager instead */
	95	/* of going to Open32 directly. */
	96	/*****************************************************************************/
	97
	98	DWORD HMHandleAllocate (PULONG phHandle16,
[3124]	99	ULONG hHandle32);
[262]	100
	101	DWORD HMHandleFree (ULONG hHandle16);
	102
[2129]	103	DWORD HMHandleGetUserData (ULONG hHandle16);
	104
[262]	105	DWORD HMHandleValidate (ULONG hHandle16);
	106
	107	DWORD HMHandleTranslateToWin (ULONG hHandle32,
[3124]	108	PULONG phHandle16);
[262]	109
	110	DWORD HMHandleTranslateToOS2 (ULONG hHandle16,
[3124]	111	PULONG hHandle32);
[262]	112
	113	DWORD HMHandleTranslateToOS2i(ULONG hHandle16);
	114
	115
	116	/*****************************************************************************
	117	* Forwarders *
	118	*****************************************************************************/
	119
	120	// enable C linkage to avoid parameter mangling
	121	#ifdef __cplusplus__
	122	extern "C" {
	123	#endif
	124
[278]	125	HANDLE HMCreateEvent (LPSECURITY_ATTRIBUTES lpsa,
	126	BOOL bManualReset,
	127	BOOL bInitialState,
	128	LPCSTR lpName);
[262]	129
[278]	130	HANDLE HMCreateMutex (LPSECURITY_ATTRIBUTES lpsa,
	131	BOOL bInitialOwner,
	132	LPCSTR lpName);
[262]	133
[278]	134	HANDLE HMCreateFile (LPCSTR lpFileName,
	135	DWORD dwDesiredAccess,
	136	DWORD dwShareMode,
	137	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	138	DWORD dwCreationDisposition,
	139	DWORD dwFlagsAndAttributes,
	140	HANDLE hTemplateFile);
[262]	141
[278]	142	HANDLE HMOpenFile (LPCSTR lpFileName,
	143	OFSTRUCT* pOFStruct,
	144	UINT fuMode);
[262]	145
[278]	146	HANDLE HMOpenEvent (DWORD fdwAccess,
	147	BOOL fInherit,
	148	LPCSTR lpName);
[262]	149
[278]	150	HANDLE HMOpenMutex (DWORD fdwAccess,
	151	BOOL fInherit,
	152	LPCSTR lpName);
[262]	153
[278]	154	BOOL HMCloseHandle (HANDLE hObject);
[262]	155
[278]	156	BOOL HMReadFile (HANDLE hFile,
	157	LPVOID lpBuffer,
	158	DWORD nNumberOfBytesToRead,
	159	LPDWORD lpNumberOfBytesRead,
	160	LPOVERLAPPED lpOverlapped);
[262]	161
[3640]	162
	163	BOOL HMReadFileEx (HANDLE hFile,
	164	LPVOID lpBuffer,
	165	DWORD nNumberOfBytesToRead,
	166	LPOVERLAPPED lpOverlapped,
	167	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
	168
[278]	169	BOOL HMWriteFile (HANDLE hFile,
	170	LPCVOID lpBuffer,
	171	DWORD nNumberOfBytesToWrite,
	172	LPDWORD lpNumberOfBytesWritten,
	173	LPOVERLAPPED lpOverlapped);
[262]	174
[3640]	175	BOOL HMWriteFileEx (HANDLE hFile,
	176	LPVOID lpBuffer,
	177	DWORD nNumberOfBytesToWrite,
	178	LPOVERLAPPED lpOverlapped,
	179	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
	180
[278]	181	DWORD HMGetFileType (HANDLE hFile);
[262]	182
[278]	183	DWORD HMDeviceRequest (HANDLE hFile,
	184	ULONG ulRequestCode,
	185	ULONG arg1,
	186	ULONG arg2,
	187	ULONG arg3,
	188	ULONG arg4);
[262]	189
[278]	190	BOOL HMGetFileInformationByHandle (HANDLE hFile,
	191	BY_HANDLE_FILE_INFORMATION *pHFI);
[262]	192
[278]	193	BOOL HMSetEndOfFile (HANDLE hFile);
[262]	194
[278]	195	BOOL HMSetFileTime (HANDLE hFile,
	196	const FILETIME *pFT1,
	197	const FILETIME *pFT2,
	198	const FILETIME *pFT3);
[262]	199
[3590]	200	BOOL HMGetFileTime (HANDLE hFile,
	201	const FILETIME *pFT1,
	202	const FILETIME *pFT2,
	203	const FILETIME *pFT3);
	204
[278]	205	DWORD HMGetFileSize (HANDLE hFile,
	206	PDWORD pSize);
[262]	207
[278]	208	DWORD HMSetFilePointer (HANDLE hFile,
	209	LONG lDistanceToMove,
	210	PLONG lpDistanceToMoveHigh,
	211	DWORD dwMoveMethod);
[262]	212
[278]	213	BOOL HMLockFile (HFILE hFile,
	214	DWORD dwFileOffsetLow,
	215	DWORD dwFileOffsetHigh,
	216	DWORD nNumberOfBytesToLockLow,
	217	DWORD nNumberOfBytesToLockHigh);
[262]	218
[278]	219	BOOL HMLockFileEx (HANDLE hFile,
	220	DWORD dwFlags,
	221	DWORD dwReserved,
	222	DWORD nNumberOfBytesToLockLow,
	223	DWORD nNumberOfBytesToLockHigh,
	224	LPOVERLAPPED lpOverlapped);
	225
	226	BOOL HMUnlockFile (HANDLE hFile,
	227	DWORD dwFileOffsetLow,
	228	DWORD dwFileOffsetHigh,
	229	DWORD cbUnlockLow,
	230	DWORD cbUnlockHigh);
	231
	232	BOOL HMUnlockFileEx (HANDLE hFile,
	233	DWORD dwReserved,
	234	DWORD nNumberOfBytesToLockLow,
	235	DWORD nNumberOfBytesToLockHigh,
	236	LPOVERLAPPED lpOverlapped);
	237
	238	DWORD HMWaitForSingleObject (HANDLE hObject,
	239	DWORD dwTimeout);
	240
	241	DWORD HMWaitForSingleObjectEx (HANDLE hObject,
	242	DWORD dwTimeout,
	243	BOOL fAlertable);
	244
	245	DWORD HMWaitForMultipleObjects (DWORD cObjects,
	246	HANDLE *lphObjects,
	247	BOOL fWaitAll,
	248	DWORD dwTimeout);
	249
	250	DWORD HMWaitForMultipleObjectsEx (DWORD cObjects,
	251	HANDLE *lphObjects,
	252	BOOL fWaitAll,
	253	DWORD dwTimeout,
	254	BOOL fAlertable);
	255
[4285]	256	DWORD HMMsgWaitForMultipleObjects (DWORD nCount,
	257	HANDLE *pHandles,
	258	BOOL fWaitAll,
	259	DWORD dwMilliseconds,
	260	DWORD dwWakeMask);
[2129]	261
[4183]	262	BOOL HMDeviceIoControl (HANDLE hDevice,
	263	DWORD dwIoControlCode,
	264	LPVOID lpInBuffer,
	265	DWORD nInBufferSize,
	266	LPVOID lpOutBuffer,
	267	DWORD nOutBufferSize,
	268	LPDWORD lpBytesReturned,
	269	LPOVERLAPPED lpOverlapped);
	270
[278]	271	BOOL HMFlushFileBuffers (HANDLE hObject);
	272
	273	BOOL HMGetOverlappedResult (HANDLE hObject,
	274	LPOVERLAPPED lpOverlapped,
	275	LPDWORD lpNumberOfBytesTransferred,
	276	BOOL bWait);
	277
	278	BOOL HMReleaseMutex (HANDLE hObject);
	279
	280	BOOL HMSetEvent (HANDLE hEvent);
	281
	282	BOOL HMPulseEvent (HANDLE hEvent);
	283
	284	BOOL HMResetEvent (HANDLE hEvent);
	285
	286	HANDLE HMCreateSemaphore (LPSECURITY_ATTRIBUTES lpsa,
	287	LONG lInitialCount,
	288	LONG lMaximumCount,
	289	LPCSTR lpszSemaphoreName);
	290
	291	HANDLE HMOpenSemaphore (DWORD fdwAccess,
	292	BOOL fInheritHandle,
	293	LPCSTR lpszSemaphoreName);
	294
	295	BOOL HMReleaseSemaphore (HANDLE hSemaphore,
	296	LONG cReleaseCount,
	297	LPLONG lpPreviousCount);
	298
	299
[664]	300	HANDLE HMCreateFileMapping(
	301	HFILE hFile, /* [in] Handle of file to map */
	302	SECURITY_ATTRIBUTES sa, / [in] Optional security attributes*/
	303	DWORD protect, /* [in] Protection for mapping object */
	304	DWORD size_high, /* [in] High-order 32 bits of object size */
	305	DWORD size_low, /* [in] Low-order 32 bits of object size */
[776]	306	LPCSTR name); /* [in] Name of file-mapping object */
[659]	307
[664]	308	HANDLE HMOpenFileMapping(
	309	DWORD access, /* [in] Access mode */
	310	BOOL inherit, /* [in] Inherit flag */
	311	LPCSTR name ); /* [in] Name of file-mapping object */
[659]	312
	313	LPVOID HMMapViewOfFileEx (HANDLE hFileMappingObject,
	314	DWORD dwDesiredAccess,
	315	DWORD dwFileOffsetHigh,
	316	DWORD dwFileOffsetLow,
	317	DWORD dwNumberOfBytesToMap,
[4285]	318	LPVOID lpBaseAddress);
[659]	319
[689]	320	BOOL HMDuplicateHandle(HANDLE srcprocess,
	321	HANDLE srchandle,
	322	HANDLE destprocess,
	323	PHANDLE desthandle,
	324	DWORD fdwAccess,
	325	BOOL fInherit,
[3951]	326	DWORD fdwOptions,
	327	DWORD fdwOdinOptions = 0);
[689]	328
[4285]	329	#define DUPLICATE_SHARE_DENYNONE 1
	330	#define DUPLICATE_SHARE_READ 2
	331	#define DUPLICATE_ACCESS_READ 4
	332	#define DUPLICATE_ACCESS_WRITE 8
	333	#define DUPLICATE_ACCESS_READWRITE (DUPLICATE_ACCESS_WRITE\|DUPLICATE_ACCESS_READ)
[3951]	334
	335	//SvL: Used internally by memory mapped class
	336	#define HMDuplicateHandleOdin HMDuplicateHandle
	337
[2129]	338	DWORD HMOpenThreadToken(HANDLE ThreadHandle,
	339	DWORD DesiredAccess,
[2326]	340	DWORD OpenAsSelf,
[2129]	341	HANDLE *TokenHandle);
	342
	343	DWORD HMOpenProcessToken(HANDLE ProcessHandle,
	344	DWORD DesiredAccess,
	345	DWORD dwUserData,
	346	HANDLE *TokenHandle);
	347
[4285]	348	BOOL HMCommSetupComm(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue);
[1856]	349
[4285]	350	BOOL HMCommGetCommState(HANDLE hCommDev, LPDCB lpdcb);
	351	BOOL HMCommWaitCommEvent( HANDLE hCommDev,
	352	LPDWORD lpfdwEvtMask,
	353	LPOVERLAPPED lpo);
[1857]	354
[4285]	355	BOOL HMCommGetCommProperties( HANDLE hCommDev,
	356	LPCOMMPROP lpcmmp);
	357
	358	BOOL HMCommGetCommMask( HANDLE hCommDev,
	359	LPDWORD lpfdwEvtMask);
	360
	361	BOOL HMCommSetCommMask( HANDLE hCommDev,
	362	DWORD fdwEvtMask);
	363
	364	BOOL HMCommPurgeComm( HANDLE hCommDev,
	365	DWORD fdwAction);
	366
	367	BOOL HMCommClearCommError( HANDLE hCommDev,
	368	LPDWORD lpdwErrors,
	369	LPCOMSTAT lpcst);
	370
	371	BOOL HMCommSetCommState( HANDLE hCommDev,
	372	LPDCB lpdcb);
	373
	374	BOOL HMCommGetCommModemStatus( HANDLE hFile,
	375	LPDWORD lpModemStat );
	376
	377	BOOL HMCommGetCommTimeouts( HANDLE hCommDev,
	378	LPCOMMTIMEOUTS lpctmo);
	379
	380	BOOL HMCommSetCommTimeouts( HANDLE hCommDev,
	381	LPCOMMTIMEOUTS lpctmo);
	382
	383	BOOL HMCommTransmitCommChar( HANDLE hFile,
	384	CHAR cChar );
	385
	386	BOOL HMCommSetCommConfig( HANDLE hCommDev,
	387	LPCOMMCONFIG lpCC,
	388	DWORD dwSize );
	389
	390	BOOL HMCommSetCommBreak( HANDLE hFile );
	391
	392	BOOL HMCommGetCommConfig( HANDLE hCommDev,
	393	LPCOMMCONFIG lpCC,
	394	LPDWORD lpdwSize );
	395
	396	BOOL HMCommEscapeCommFunction( HANDLE hFile,
	397	UINT dwFunc );
	398
	399	BOOL HMCommSetupComm( HANDLE hFile,
	400	DWORD dwInQueue,
	401	DWORD dwOutQueue);
	402
	403	BOOL HMCommClearCommBreak(HANDLE hFile);
	404
	405	BOOL HMCommSetDefaultCommConfig( HANDLE hCOM,
	406	LPCOMMCONFIG lpCC,
	407	DWORD dwSize);
	408
	409	BOOL HMCommGetDefaultCommConfig( HANDLE hCOM,
	410	LPCOMMCONFIG lpCC,
	411	LPDWORD lpdwSize);
	412
[3124]	413	HANDLE HMCreateThread(LPSECURITY_ATTRIBUTES lpsa,
	414	DWORD cbStack,
	415	LPTHREAD_START_ROUTINE lpStartAddr,
	416	LPVOID lpvThreadParm,
	417	DWORD fdwCreate,
[3138]	418	LPDWORD lpIDThread,
	419	BOOL fFirstThread = FALSE);
[3124]	420	INT HMGetThreadPriority(HANDLE hThread);
	421	DWORD HMSuspendThread(HANDLE hThread);
	422	BOOL HMSetThreadPriority(HANDLE hThread, int priority);
	423	BOOL HMGetThreadContext(HANDLE hThread, CONTEXT *lpContext);
	424	BOOL HMSetThreadContext(HANDLE hThread, const CONTEXT *lpContext);
	425	BOOL HMTerminateThread(HANDLE hThread, DWORD exitcode);
	426	DWORD HMResumeThread(HANDLE hThread);
	427	BOOL HMGetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode);
	428	BOOL HMSetThreadTerminated(HANDLE hThread);
[3819]	429	BOOL HMPeekNamedPipe(HANDLE pHMHandleData,
	430	LPVOID lpvBuffer,
	431	DWORD cbBuffer,
	432	LPDWORD lpcbRead,
	433	LPDWORD lpcbAvail,
	434	LPDWORD lpcbMessage);
[3124]	435
[4183]	436	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	437	DWORD dwOpenMode,
[3819]	438	DWORD dwPipeMode,
[4183]	439	DWORD nMaxInstances,
[3819]	440	DWORD nOutBufferSize,
[4183]	441	DWORD nInBufferSize,
[3819]	442	DWORD nDefaultTimeOut,
	443	LPSECURITY_ATTRIBUTES lpSecurityAttributes);
	444
	445	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	446
	447	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	448
	449	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	450	LPDWORD lpState,
	451	LPDWORD lpCurInstances,
	452	LPDWORD lpMaxCollectionCount,
	453	LPDWORD lpCollectDataTimeout,
	454	LPTSTR lpUserName,
	455	DWORD nMaxUserNameSize);
	456
	457	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	458	LPDWORD lpFlags,
	459	LPDWORD lpOutBufferSize,
	460	LPDWORD lpInBufferSize,
	461	LPDWORD lpMaxInstances);
	462
	463
	464	DWORD HMTransactNamedPipe(HANDLE hPipe,
	465	LPVOID lpvWriteBuf,
	466	DWORD cbWriteBuf,
	467	LPVOID lpvReadBuf,
	468	DWORD cbReadBuf,
	469	LPDWORD lpcbRead,
	470	LPOVERLAPPED lpo);
	471
	472
	473	BOOL HMPeekNamedPipe(HANDLE hPipe,
	474	LPVOID lpvBuffer,
	475	DWORD cbBuffer,
	476	LPDWORD lpcbRead,
	477	LPDWORD lpcbAvail,
	478	LPDWORD lpcbMessage);
	479
[4183]	480	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	481	DWORD dwOpenMode,
[3819]	482	DWORD dwPipeMode,
[4183]	483	DWORD nMaxInstances,
[3819]	484	DWORD nOutBufferSize,
[4183]	485	DWORD nInBufferSize,
[3819]	486	DWORD nDefaultTimeOut,
	487	void* lpSecurityAttributes);
	488
	489	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	490
	491	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	492
	493	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	494	LPDWORD lpState,
	495	LPDWORD lpCurInstances,
	496	LPDWORD lpMaxCollectionCount,
	497	LPDWORD lpCollectDataTimeout,
	498	LPTSTR lpUserName,
	499	DWORD nMaxUserNameSize);
	500
	501	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	502	LPDWORD lpFlags,
	503	LPDWORD lpOutBufferSize,
	504	LPDWORD lpInBufferSize,
	505	LPDWORD lpMaxInstances);
	506
	507	DWORD HMTransactNamedPipe(HANDLE hPipe,
	508	LPVOID lpvWriteBuf,
	509	DWORD cbWriteBuf,
	510	LPVOID lpvReadBuf,
	511	DWORD cbReadBuf,
	512	LPDWORD lpcbRead,
	513	LPOVERLAPPED lpo);
	514
	515	BOOL HMSetNamedPipeHandleState(HANDLE hNamedPipe,
	516	LPDWORD lpdwMode,
	517	LPDWORD lpcbMaxCollect,
	518	LPDWORD lpdwCollectDataTimeout);
	519
	520	BOOL HMCreatePipe(PHANDLE phRead,
	521	PHANDLE phWrite,
[4183]	522	LPSECURITY_ATTRIBUTES lpsa,
[3819]	523	DWORD cbPipe);
	524
[262]	525	#ifdef __cplusplus__
	526	}
	527	#endif
	528
	529	#endif /* _HANDLEMANAGER_H_ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: