Context Navigation

source: trunk/include/HandleManager.h@ 7155

Visit:

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

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

Download in other formats: