Context Navigation

source: trunk/include/HandleManager.h@ 6937

Visit:

Last change on this file since 6937 was 6937, checked in by sandervl, 24 years ago
header update
File size: 23.7 KB

Rev	Line
[6937]	1	/* $Id: HandleManager.h,v 1.26 2001-10-03 13:50:58 sandervl 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);
[6937]	104	DWORD HMHandleSetUserData (ULONG hHandle16, ULONG dwUserData);
[2129]	105
[262]	106	DWORD HMHandleValidate (ULONG hHandle16);
	107
	108	DWORD HMHandleTranslateToWin (ULONG hHandle32,
[3124]	109	PULONG phHandle16);
[262]	110
	111	DWORD HMHandleTranslateToOS2 (ULONG hHandle16,
[3124]	112	PULONG hHandle32);
[262]	113
	114	DWORD HMHandleTranslateToOS2i(ULONG hHandle16);
	115
	116
	117	/*****************************************************************************
	118	* Forwarders *
	119	*****************************************************************************/
	120
	121	// enable C linkage to avoid parameter mangling
	122	#ifdef __cplusplus__
	123	extern "C" {
	124	#endif
	125
[278]	126	HANDLE HMCreateEvent (LPSECURITY_ATTRIBUTES lpsa,
	127	BOOL bManualReset,
	128	BOOL bInitialState,
	129	LPCSTR lpName);
[262]	130
[278]	131	HANDLE HMCreateMutex (LPSECURITY_ATTRIBUTES lpsa,
	132	BOOL bInitialOwner,
	133	LPCSTR lpName);
[262]	134
[278]	135	HANDLE HMCreateFile (LPCSTR lpFileName,
	136	DWORD dwDesiredAccess,
	137	DWORD dwShareMode,
	138	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	139	DWORD dwCreationDisposition,
	140	DWORD dwFlagsAndAttributes,
	141	HANDLE hTemplateFile);
[262]	142
[278]	143	HANDLE HMOpenFile (LPCSTR lpFileName,
	144	OFSTRUCT* pOFStruct,
	145	UINT fuMode);
[262]	146
[278]	147	HANDLE HMOpenEvent (DWORD fdwAccess,
	148	BOOL fInherit,
	149	LPCSTR lpName);
[262]	150
[278]	151	HANDLE HMOpenMutex (DWORD fdwAccess,
	152	BOOL fInherit,
	153	LPCSTR lpName);
[262]	154
[278]	155	BOOL HMCloseHandle (HANDLE hObject);
[262]	156
[278]	157	BOOL HMReadFile (HANDLE hFile,
	158	LPVOID lpBuffer,
	159	DWORD nNumberOfBytesToRead,
	160	LPDWORD lpNumberOfBytesRead,
	161	LPOVERLAPPED lpOverlapped);
[262]	162
[3640]	163
	164	BOOL HMReadFileEx (HANDLE hFile,
	165	LPVOID lpBuffer,
	166	DWORD nNumberOfBytesToRead,
	167	LPOVERLAPPED lpOverlapped,
	168	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
	169
[278]	170	BOOL HMWriteFile (HANDLE hFile,
	171	LPCVOID lpBuffer,
	172	DWORD nNumberOfBytesToWrite,
	173	LPDWORD lpNumberOfBytesWritten,
	174	LPOVERLAPPED lpOverlapped);
[262]	175
[3640]	176	BOOL HMWriteFileEx (HANDLE hFile,
	177	LPVOID lpBuffer,
	178	DWORD nNumberOfBytesToWrite,
	179	LPOVERLAPPED lpOverlapped,
	180	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
	181
[278]	182	DWORD HMGetFileType (HANDLE hFile);
[262]	183
[278]	184	DWORD HMDeviceRequest (HANDLE hFile,
	185	ULONG ulRequestCode,
	186	ULONG arg1,
	187	ULONG arg2,
	188	ULONG arg3,
	189	ULONG arg4);
[262]	190
[278]	191	BOOL HMGetFileInformationByHandle (HANDLE hFile,
	192	BY_HANDLE_FILE_INFORMATION *pHFI);
[262]	193
[278]	194	BOOL HMSetEndOfFile (HANDLE hFile);
[262]	195
[278]	196	BOOL HMSetFileTime (HANDLE hFile,
	197	const FILETIME *pFT1,
	198	const FILETIME *pFT2,
	199	const FILETIME *pFT3);
[262]	200
[3590]	201	BOOL HMGetFileTime (HANDLE hFile,
	202	const FILETIME *pFT1,
	203	const FILETIME *pFT2,
	204	const FILETIME *pFT3);
	205
[278]	206	DWORD HMGetFileSize (HANDLE hFile,
	207	PDWORD pSize);
[262]	208
[278]	209	DWORD HMSetFilePointer (HANDLE hFile,
	210	LONG lDistanceToMove,
	211	PLONG lpDistanceToMoveHigh,
	212	DWORD dwMoveMethod);
[262]	213
[278]	214	BOOL HMLockFile (HFILE hFile,
	215	DWORD dwFileOffsetLow,
	216	DWORD dwFileOffsetHigh,
	217	DWORD nNumberOfBytesToLockLow,
	218	DWORD nNumberOfBytesToLockHigh);
[262]	219
[278]	220	BOOL HMLockFileEx (HANDLE hFile,
	221	DWORD dwFlags,
	222	DWORD dwReserved,
	223	DWORD nNumberOfBytesToLockLow,
	224	DWORD nNumberOfBytesToLockHigh,
	225	LPOVERLAPPED lpOverlapped);
	226
	227	BOOL HMUnlockFile (HANDLE hFile,
	228	DWORD dwFileOffsetLow,
	229	DWORD dwFileOffsetHigh,
	230	DWORD cbUnlockLow,
	231	DWORD cbUnlockHigh);
	232
	233	BOOL HMUnlockFileEx (HANDLE hFile,
	234	DWORD dwReserved,
	235	DWORD nNumberOfBytesToLockLow,
	236	DWORD nNumberOfBytesToLockHigh,
	237	LPOVERLAPPED lpOverlapped);
	238
	239	DWORD HMWaitForSingleObject (HANDLE hObject,
	240	DWORD dwTimeout);
	241
	242	DWORD HMWaitForSingleObjectEx (HANDLE hObject,
	243	DWORD dwTimeout,
	244	BOOL fAlertable);
	245
	246	DWORD HMWaitForMultipleObjects (DWORD cObjects,
	247	HANDLE *lphObjects,
	248	BOOL fWaitAll,
	249	DWORD dwTimeout);
	250
	251	DWORD HMWaitForMultipleObjectsEx (DWORD cObjects,
	252	HANDLE *lphObjects,
	253	BOOL fWaitAll,
	254	DWORD dwTimeout,
	255	BOOL fAlertable);
	256
[4285]	257	DWORD HMMsgWaitForMultipleObjects (DWORD nCount,
	258	HANDLE *pHandles,
	259	BOOL fWaitAll,
	260	DWORD dwMilliseconds,
	261	DWORD dwWakeMask);
[2129]	262
[4183]	263	BOOL HMDeviceIoControl (HANDLE hDevice,
	264	DWORD dwIoControlCode,
	265	LPVOID lpInBuffer,
	266	DWORD nInBufferSize,
	267	LPVOID lpOutBuffer,
	268	DWORD nOutBufferSize,
	269	LPDWORD lpBytesReturned,
	270	LPOVERLAPPED lpOverlapped);
	271
[278]	272	BOOL HMFlushFileBuffers (HANDLE hObject);
	273
	274	BOOL HMGetOverlappedResult (HANDLE hObject,
	275	LPOVERLAPPED lpOverlapped,
	276	LPDWORD lpNumberOfBytesTransferred,
	277	BOOL bWait);
	278
	279	BOOL HMReleaseMutex (HANDLE hObject);
	280
	281	BOOL HMSetEvent (HANDLE hEvent);
	282
	283	BOOL HMPulseEvent (HANDLE hEvent);
	284
	285	BOOL HMResetEvent (HANDLE hEvent);
	286
	287	HANDLE HMCreateSemaphore (LPSECURITY_ATTRIBUTES lpsa,
	288	LONG lInitialCount,
	289	LONG lMaximumCount,
	290	LPCSTR lpszSemaphoreName);
	291
	292	HANDLE HMOpenSemaphore (DWORD fdwAccess,
	293	BOOL fInheritHandle,
	294	LPCSTR lpszSemaphoreName);
	295
	296	BOOL HMReleaseSemaphore (HANDLE hSemaphore,
	297	LONG cReleaseCount,
	298	LPLONG lpPreviousCount);
	299
	300
[664]	301	HANDLE HMCreateFileMapping(
	302	HFILE hFile, /* [in] Handle of file to map */
	303	SECURITY_ATTRIBUTES sa, / [in] Optional security attributes*/
	304	DWORD protect, /* [in] Protection for mapping object */
	305	DWORD size_high, /* [in] High-order 32 bits of object size */
	306	DWORD size_low, /* [in] Low-order 32 bits of object size */
[776]	307	LPCSTR name); /* [in] Name of file-mapping object */
[659]	308
[664]	309	HANDLE HMOpenFileMapping(
	310	DWORD access, /* [in] Access mode */
	311	BOOL inherit, /* [in] Inherit flag */
	312	LPCSTR name ); /* [in] Name of file-mapping object */
[659]	313
	314	LPVOID HMMapViewOfFileEx (HANDLE hFileMappingObject,
	315	DWORD dwDesiredAccess,
	316	DWORD dwFileOffsetHigh,
	317	DWORD dwFileOffsetLow,
	318	DWORD dwNumberOfBytesToMap,
[4285]	319	LPVOID lpBaseAddress);
[659]	320
[689]	321	BOOL HMDuplicateHandle(HANDLE srcprocess,
	322	HANDLE srchandle,
	323	HANDLE destprocess,
	324	PHANDLE desthandle,
	325	DWORD fdwAccess,
	326	BOOL fInherit,
[3951]	327	DWORD fdwOptions,
	328	DWORD fdwOdinOptions = 0);
[689]	329
[4285]	330	#define DUPLICATE_SHARE_DENYNONE 1
	331	#define DUPLICATE_SHARE_READ 2
	332	#define DUPLICATE_ACCESS_READ 4
	333	#define DUPLICATE_ACCESS_WRITE 8
	334	#define DUPLICATE_ACCESS_READWRITE (DUPLICATE_ACCESS_WRITE\|DUPLICATE_ACCESS_READ)
[3951]	335
	336	//SvL: Used internally by memory mapped class
	337	#define HMDuplicateHandleOdin HMDuplicateHandle
	338
[2129]	339	DWORD HMOpenThreadToken(HANDLE ThreadHandle,
	340	DWORD DesiredAccess,
[2326]	341	DWORD OpenAsSelf,
[2129]	342	HANDLE *TokenHandle);
	343
	344	DWORD HMOpenProcessToken(HANDLE ProcessHandle,
	345	DWORD DesiredAccess,
	346	DWORD dwUserData,
	347	HANDLE *TokenHandle);
	348
[4285]	349	BOOL HMCommSetupComm(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue);
[1856]	350
[4285]	351	BOOL HMCommGetCommState(HANDLE hCommDev, LPDCB lpdcb);
	352	BOOL HMCommWaitCommEvent( HANDLE hCommDev,
	353	LPDWORD lpfdwEvtMask,
	354	LPOVERLAPPED lpo);
[1857]	355
[4285]	356	BOOL HMCommGetCommProperties( HANDLE hCommDev,
	357	LPCOMMPROP lpcmmp);
	358
	359	BOOL HMCommGetCommMask( HANDLE hCommDev,
	360	LPDWORD lpfdwEvtMask);
	361
	362	BOOL HMCommSetCommMask( HANDLE hCommDev,
	363	DWORD fdwEvtMask);
	364
	365	BOOL HMCommPurgeComm( HANDLE hCommDev,
	366	DWORD fdwAction);
	367
	368	BOOL HMCommClearCommError( HANDLE hCommDev,
	369	LPDWORD lpdwErrors,
	370	LPCOMSTAT lpcst);
	371
	372	BOOL HMCommSetCommState( HANDLE hCommDev,
	373	LPDCB lpdcb);
	374
	375	BOOL HMCommGetCommModemStatus( HANDLE hFile,
	376	LPDWORD lpModemStat );
	377
	378	BOOL HMCommGetCommTimeouts( HANDLE hCommDev,
	379	LPCOMMTIMEOUTS lpctmo);
	380
	381	BOOL HMCommSetCommTimeouts( HANDLE hCommDev,
	382	LPCOMMTIMEOUTS lpctmo);
	383
	384	BOOL HMCommTransmitCommChar( HANDLE hFile,
	385	CHAR cChar );
	386
	387	BOOL HMCommSetCommConfig( HANDLE hCommDev,
	388	LPCOMMCONFIG lpCC,
	389	DWORD dwSize );
	390
	391	BOOL HMCommSetCommBreak( HANDLE hFile );
	392
	393	BOOL HMCommGetCommConfig( HANDLE hCommDev,
	394	LPCOMMCONFIG lpCC,
	395	LPDWORD lpdwSize );
	396
	397	BOOL HMCommEscapeCommFunction( HANDLE hFile,
	398	UINT dwFunc );
	399
	400	BOOL HMCommSetupComm( HANDLE hFile,
	401	DWORD dwInQueue,
	402	DWORD dwOutQueue);
	403
	404	BOOL HMCommClearCommBreak(HANDLE hFile);
	405
	406	BOOL HMCommSetDefaultCommConfig( HANDLE hCOM,
	407	LPCOMMCONFIG lpCC,
	408	DWORD dwSize);
	409
	410	BOOL HMCommGetDefaultCommConfig( HANDLE hCOM,
	411	LPCOMMCONFIG lpCC,
	412	LPDWORD lpdwSize);
	413
[3124]	414	HANDLE HMCreateThread(LPSECURITY_ATTRIBUTES lpsa,
	415	DWORD cbStack,
	416	LPTHREAD_START_ROUTINE lpStartAddr,
	417	LPVOID lpvThreadParm,
	418	DWORD fdwCreate,
[3138]	419	LPDWORD lpIDThread,
	420	BOOL fFirstThread = FALSE);
[3124]	421	INT HMGetThreadPriority(HANDLE hThread);
	422	DWORD HMSuspendThread(HANDLE hThread);
	423	BOOL HMSetThreadPriority(HANDLE hThread, int priority);
	424	BOOL HMGetThreadContext(HANDLE hThread, CONTEXT *lpContext);
	425	BOOL HMSetThreadContext(HANDLE hThread, const CONTEXT *lpContext);
	426	BOOL HMTerminateThread(HANDLE hThread, DWORD exitcode);
	427	DWORD HMResumeThread(HANDLE hThread);
	428	BOOL HMGetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode);
	429	BOOL HMSetThreadTerminated(HANDLE hThread);
[3819]	430	BOOL HMPeekNamedPipe(HANDLE pHMHandleData,
	431	LPVOID lpvBuffer,
	432	DWORD cbBuffer,
	433	LPDWORD lpcbRead,
	434	LPDWORD lpcbAvail,
	435	LPDWORD lpcbMessage);
[3124]	436
[4183]	437	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	438	DWORD dwOpenMode,
[3819]	439	DWORD dwPipeMode,
[4183]	440	DWORD nMaxInstances,
[3819]	441	DWORD nOutBufferSize,
[4183]	442	DWORD nInBufferSize,
[3819]	443	DWORD nDefaultTimeOut,
	444	LPSECURITY_ATTRIBUTES lpSecurityAttributes);
	445
	446	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	447
	448	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	449
	450	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	451	LPDWORD lpState,
	452	LPDWORD lpCurInstances,
	453	LPDWORD lpMaxCollectionCount,
	454	LPDWORD lpCollectDataTimeout,
	455	LPTSTR lpUserName,
	456	DWORD nMaxUserNameSize);
	457
	458	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	459	LPDWORD lpFlags,
	460	LPDWORD lpOutBufferSize,
	461	LPDWORD lpInBufferSize,
	462	LPDWORD lpMaxInstances);
	463
	464
	465	DWORD HMTransactNamedPipe(HANDLE hPipe,
	466	LPVOID lpvWriteBuf,
	467	DWORD cbWriteBuf,
	468	LPVOID lpvReadBuf,
	469	DWORD cbReadBuf,
	470	LPDWORD lpcbRead,
	471	LPOVERLAPPED lpo);
	472
	473
	474	BOOL HMPeekNamedPipe(HANDLE hPipe,
	475	LPVOID lpvBuffer,
	476	DWORD cbBuffer,
	477	LPDWORD lpcbRead,
	478	LPDWORD lpcbAvail,
	479	LPDWORD lpcbMessage);
	480
[4183]	481	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	482	DWORD dwOpenMode,
[3819]	483	DWORD dwPipeMode,
[4183]	484	DWORD nMaxInstances,
[3819]	485	DWORD nOutBufferSize,
[4183]	486	DWORD nInBufferSize,
[3819]	487	DWORD nDefaultTimeOut,
	488	void* lpSecurityAttributes);
	489
	490	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	491
	492	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	493
	494	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	495	LPDWORD lpState,
	496	LPDWORD lpCurInstances,
	497	LPDWORD lpMaxCollectionCount,
	498	LPDWORD lpCollectDataTimeout,
	499	LPTSTR lpUserName,
	500	DWORD nMaxUserNameSize);
	501
	502	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	503	LPDWORD lpFlags,
	504	LPDWORD lpOutBufferSize,
	505	LPDWORD lpInBufferSize,
	506	LPDWORD lpMaxInstances);
	507
	508	DWORD HMTransactNamedPipe(HANDLE hPipe,
	509	LPVOID lpvWriteBuf,
	510	DWORD cbWriteBuf,
	511	LPVOID lpvReadBuf,
	512	DWORD cbReadBuf,
	513	LPDWORD lpcbRead,
	514	LPOVERLAPPED lpo);
	515
	516	BOOL HMSetNamedPipeHandleState(HANDLE hNamedPipe,
	517	LPDWORD lpdwMode,
	518	LPDWORD lpcbMaxCollect,
	519	LPDWORD lpdwCollectDataTimeout);
	520
	521	BOOL HMCreatePipe(PHANDLE phRead,
	522	PHANDLE phWrite,
[4183]	523	LPSECURITY_ATTRIBUTES lpsa,
[3819]	524	DWORD cbPipe);
	525
[5590]	526
	527	//Mailslot API
	528	HANDLE HMCreateMailslotA(LPCSTR lpName, DWORD nMaxMessageSize,
	529	DWORD lReadTimeout,
	530	LPSECURITY_ATTRIBUTES lpSecurityAttributes);
	531	BOOL HMGetMailslotInfo(HANDLE hMailslot,
	532	LPDWORD lpMaxMessageSize,
	533	LPDWORD lpNextSize,
	534	LPDWORD lpMessageCount,
	535	LPDWORD lpReadTimeout);
	536	BOOL HMSetMailslotInfo(HANDLE hMailslot,
	537	DWORD dwReadTimeout);
	538
[262]	539	#ifdef __cplusplus__
	540	}
	541	#endif
	542
	543	#endif /* _HANDLEMANAGER_H_ */

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

Download in other formats: