Context Navigation

source: trunk/include/HandleManager.h@ 9912

Visit:

Last change on this file since 9912 was 9912, checked in by sandervl, 22 years ago
update
File size: 23.1 KB

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

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

Download in other formats: