Context Navigation

source: trunk/include/HandleManager.h@ 10010

Visit:

Last change on this file since 10010 was 10010, checked in by sandervl, 22 years ago
DF: Console updates
File size: 23.2 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
[10010]	86	BOOL HMUpdtStdHandle(DWORD nStdHandle,
	87	HANDLE hHandle);
[262]	88
[10010]	89
[262]	90	/*****************************************************************************/
	91	/* handle translation buffer management */
	92	/* */
	93	/* Since some Win32 applications rely (!) on 16-bit handles, we've got to do */
	94	/* 32-bit to 16-bit and vs vsa translation here. */
	95	/* Filehandle-based functions should be routed via the handlemanager instead */
	96	/* of going to Open32 directly. */
	97	/*****************************************************************************/
	98
	99	DWORD HMHandleAllocate (PULONG phHandle16,
[3124]	100	ULONG hHandle32);
[262]	101
	102	DWORD HMHandleFree (ULONG hHandle16);
	103
[2129]	104	DWORD HMHandleGetUserData (ULONG hHandle16);
[6937]	105	DWORD HMHandleSetUserData (ULONG hHandle16, ULONG dwUserData);
[2129]	106
[262]	107	DWORD HMHandleValidate (ULONG hHandle16);
	108
	109	DWORD HMHandleTranslateToWin (ULONG hHandle32,
[3124]	110	PULONG phHandle16);
[262]	111
	112	DWORD HMHandleTranslateToOS2 (ULONG hHandle16,
[3124]	113	PULONG hHandle32);
[262]	114
	115	DWORD HMHandleTranslateToOS2i(ULONG hHandle16);
	116
	117
	118	/*****************************************************************************
	119	* Forwarders *
	120	*****************************************************************************/
	121
	122	// enable C linkage to avoid parameter mangling
	123	#ifdef __cplusplus__
	124	extern "C" {
	125	#endif
	126
[278]	127	HANDLE HMCreateEvent (LPSECURITY_ATTRIBUTES lpsa,
	128	BOOL bManualReset,
	129	BOOL bInitialState,
	130	LPCSTR lpName);
[262]	131
[278]	132	HANDLE HMCreateMutex (LPSECURITY_ATTRIBUTES lpsa,
	133	BOOL bInitialOwner,
	134	LPCSTR lpName);
[262]	135
[278]	136	HANDLE HMCreateFile (LPCSTR lpFileName,
	137	DWORD dwDesiredAccess,
	138	DWORD dwShareMode,
	139	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	140	DWORD dwCreationDisposition,
	141	DWORD dwFlagsAndAttributes,
	142	HANDLE hTemplateFile);
[262]	143
[278]	144	HANDLE HMOpenFile (LPCSTR lpFileName,
	145	OFSTRUCT* pOFStruct,
	146	UINT fuMode);
[262]	147
[278]	148	HANDLE HMOpenEvent (DWORD fdwAccess,
	149	BOOL fInherit,
	150	LPCSTR lpName);
[262]	151
[278]	152	HANDLE HMOpenMutex (DWORD fdwAccess,
	153	BOOL fInherit,
	154	LPCSTR lpName);
[262]	155
[9652]	156	BOOL HMSetHandleInformation (HANDLE hObject,
	157	DWORD dwMask,
	158	DWORD dwFlags);
	159
	160	BOOL HMGetHandleInformation (HANDLE hObject,
	161	LPDWORD lpdwFlags);
	162
[278]	163	BOOL HMCloseHandle (HANDLE hObject);
[262]	164
[278]	165	BOOL HMReadFile (HANDLE hFile,
	166	LPVOID lpBuffer,
	167	DWORD nNumberOfBytesToRead,
	168	LPDWORD lpNumberOfBytesRead,
[3640]	169	LPOVERLAPPED lpOverlapped,
	170	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
	171
[278]	172	BOOL HMWriteFile (HANDLE hFile,
	173	LPCVOID lpBuffer,
	174	DWORD nNumberOfBytesToWrite,
	175	LPDWORD lpNumberOfBytesWritten,
[7548]	176	LPOVERLAPPED lpOverlapped,
	177	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
[262]	178
[278]	179	DWORD HMGetFileType (HANDLE hFile);
[262]	180
[278]	181	DWORD HMDeviceRequest (HANDLE hFile,
	182	ULONG ulRequestCode,
	183	ULONG arg1,
	184	ULONG arg2,
	185	ULONG arg3,
	186	ULONG arg4);
[262]	187
[278]	188	BOOL HMGetFileInformationByHandle (HANDLE hFile,
	189	BY_HANDLE_FILE_INFORMATION *pHFI);
[262]	190
[278]	191	BOOL HMSetEndOfFile (HANDLE hFile);
[262]	192
[278]	193	BOOL HMSetFileTime (HANDLE hFile,
	194	const FILETIME *pFT1,
	195	const FILETIME *pFT2,
	196	const FILETIME *pFT3);
[262]	197
[3590]	198	BOOL HMGetFileTime (HANDLE hFile,
	199	const FILETIME *pFT1,
	200	const FILETIME *pFT2,
	201	const FILETIME *pFT3);
	202
[278]	203	DWORD HMGetFileSize (HANDLE hFile,
	204	PDWORD pSize);
[262]	205
[278]	206	DWORD HMSetFilePointer (HANDLE hFile,
	207	LONG lDistanceToMove,
	208	PLONG lpDistanceToMoveHigh,
	209	DWORD dwMoveMethod);
[262]	210
[278]	211	BOOL HMLockFile (HFILE hFile,
	212	DWORD dwFileOffsetLow,
	213	DWORD dwFileOffsetHigh,
	214	DWORD nNumberOfBytesToLockLow,
	215	DWORD nNumberOfBytesToLockHigh);
[262]	216
[278]	217	BOOL HMLockFileEx (HANDLE hFile,
	218	DWORD dwFlags,
	219	DWORD dwReserved,
	220	DWORD nNumberOfBytesToLockLow,
	221	DWORD nNumberOfBytesToLockHigh,
	222	LPOVERLAPPED lpOverlapped);
	223
	224	BOOL HMUnlockFile (HANDLE hFile,
	225	DWORD dwFileOffsetLow,
	226	DWORD dwFileOffsetHigh,
	227	DWORD cbUnlockLow,
	228	DWORD cbUnlockHigh);
	229
	230	BOOL HMUnlockFileEx (HANDLE hFile,
	231	DWORD dwReserved,
	232	DWORD nNumberOfBytesToLockLow,
	233	DWORD nNumberOfBytesToLockHigh,
	234	LPOVERLAPPED lpOverlapped);
	235
	236	DWORD HMWaitForSingleObject (HANDLE hObject,
	237	DWORD dwTimeout);
	238
	239	DWORD HMWaitForSingleObjectEx (HANDLE hObject,
	240	DWORD dwTimeout,
	241	BOOL fAlertable);
	242
	243	DWORD HMWaitForMultipleObjects (DWORD cObjects,
	244	HANDLE *lphObjects,
	245	BOOL fWaitAll,
	246	DWORD dwTimeout);
	247
	248	DWORD HMWaitForMultipleObjectsEx (DWORD cObjects,
	249	HANDLE *lphObjects,
	250	BOOL fWaitAll,
	251	DWORD dwTimeout,
	252	BOOL fAlertable);
	253
[4285]	254	DWORD HMMsgWaitForMultipleObjects (DWORD nCount,
	255	HANDLE *pHandles,
	256	BOOL fWaitAll,
	257	DWORD dwMilliseconds,
	258	DWORD dwWakeMask);
[2129]	259
[4183]	260	BOOL HMDeviceIoControl (HANDLE hDevice,
	261	DWORD dwIoControlCode,
	262	LPVOID lpInBuffer,
	263	DWORD nInBufferSize,
	264	LPVOID lpOutBuffer,
	265	DWORD nOutBufferSize,
	266	LPDWORD lpBytesReturned,
	267	LPOVERLAPPED lpOverlapped);
	268
[7456]	269	BOOL HMCancelIo (HANDLE hDevice);
	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(
[9969]	301	HANDLE hFile, /* [in] Handle of file to map */
[664]	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,
[9912]	326	DWORD fdwOptions);
[689]	327
[2129]	328	DWORD HMOpenThreadToken(HANDLE ThreadHandle,
	329	DWORD DesiredAccess,
[2326]	330	DWORD OpenAsSelf,
[2129]	331	HANDLE *TokenHandle);
	332
	333	DWORD HMOpenProcessToken(HANDLE ProcessHandle,
	334	DWORD DesiredAccess,
	335	DWORD dwUserData,
	336	HANDLE *TokenHandle);
	337
[4285]	338	BOOL HMCommSetupComm(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue);
[1856]	339
[4285]	340	BOOL HMCommGetCommState(HANDLE hCommDev, LPDCB lpdcb);
	341	BOOL HMCommWaitCommEvent( HANDLE hCommDev,
	342	LPDWORD lpfdwEvtMask,
	343	LPOVERLAPPED lpo);
[1857]	344
[4285]	345	BOOL HMCommGetCommProperties( HANDLE hCommDev,
	346	LPCOMMPROP lpcmmp);
	347
	348	BOOL HMCommGetCommMask( HANDLE hCommDev,
	349	LPDWORD lpfdwEvtMask);
	350
	351	BOOL HMCommSetCommMask( HANDLE hCommDev,
	352	DWORD fdwEvtMask);
	353
	354	BOOL HMCommPurgeComm( HANDLE hCommDev,
	355	DWORD fdwAction);
	356
	357	BOOL HMCommClearCommError( HANDLE hCommDev,
	358	LPDWORD lpdwErrors,
	359	LPCOMSTAT lpcst);
	360
	361	BOOL HMCommSetCommState( HANDLE hCommDev,
	362	LPDCB lpdcb);
	363
	364	BOOL HMCommGetCommModemStatus( HANDLE hFile,
	365	LPDWORD lpModemStat );
	366
	367	BOOL HMCommGetCommTimeouts( HANDLE hCommDev,
	368	LPCOMMTIMEOUTS lpctmo);
	369
	370	BOOL HMCommSetCommTimeouts( HANDLE hCommDev,
	371	LPCOMMTIMEOUTS lpctmo);
	372
	373	BOOL HMCommTransmitCommChar( HANDLE hFile,
	374	CHAR cChar );
	375
	376	BOOL HMCommSetCommConfig( HANDLE hCommDev,
	377	LPCOMMCONFIG lpCC,
	378	DWORD dwSize );
	379
	380	BOOL HMCommSetCommBreak( HANDLE hFile );
	381
	382	BOOL HMCommGetCommConfig( HANDLE hCommDev,
	383	LPCOMMCONFIG lpCC,
	384	LPDWORD lpdwSize );
	385
	386	BOOL HMCommEscapeCommFunction( HANDLE hFile,
	387	UINT dwFunc );
	388
	389	BOOL HMCommSetupComm( HANDLE hFile,
	390	DWORD dwInQueue,
	391	DWORD dwOutQueue);
	392
	393	BOOL HMCommClearCommBreak(HANDLE hFile);
	394
	395	BOOL HMCommSetDefaultCommConfig( HANDLE hCOM,
	396	LPCOMMCONFIG lpCC,
	397	DWORD dwSize);
	398
	399	BOOL HMCommGetDefaultCommConfig( HANDLE hCOM,
	400	LPCOMMCONFIG lpCC,
	401	LPDWORD lpdwSize);
	402
[3124]	403	HANDLE HMCreateThread(LPSECURITY_ATTRIBUTES lpsa,
	404	DWORD cbStack,
	405	LPTHREAD_START_ROUTINE lpStartAddr,
	406	LPVOID lpvThreadParm,
	407	DWORD fdwCreate,
[3138]	408	LPDWORD lpIDThread,
	409	BOOL fFirstThread = FALSE);
[3124]	410	INT HMGetThreadPriority(HANDLE hThread);
	411	DWORD HMSuspendThread(HANDLE hThread);
	412	BOOL HMSetThreadPriority(HANDLE hThread, int priority);
	413	BOOL HMGetThreadContext(HANDLE hThread, CONTEXT *lpContext);
	414	BOOL HMSetThreadContext(HANDLE hThread, const CONTEXT *lpContext);
[9747]	415	BOOL HMGetThreadTimes(HANDLE hThread, FILETIME *lpCreationTime,
	416	FILETIME lpExitTime, FILETIME lpKernelTime,
	417	FILETIME *lpUserTime);
[3124]	418	BOOL HMTerminateThread(HANDLE hThread, DWORD exitcode);
	419	DWORD HMResumeThread(HANDLE hThread);
	420	BOOL HMGetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode);
	421	BOOL HMSetThreadTerminated(HANDLE hThread);
[3819]	422	BOOL HMPeekNamedPipe(HANDLE pHMHandleData,
	423	LPVOID lpvBuffer,
	424	DWORD cbBuffer,
	425	LPDWORD lpcbRead,
	426	LPDWORD lpcbAvail,
	427	LPDWORD lpcbMessage);
[3124]	428
[4183]	429	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	430	DWORD dwOpenMode,
[3819]	431	DWORD dwPipeMode,
[4183]	432	DWORD nMaxInstances,
[3819]	433	DWORD nOutBufferSize,
[4183]	434	DWORD nInBufferSize,
[3819]	435	DWORD nDefaultTimeOut,
	436	LPSECURITY_ATTRIBUTES lpSecurityAttributes);
	437
	438	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	439
	440	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	441
	442	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	443	LPDWORD lpState,
	444	LPDWORD lpCurInstances,
	445	LPDWORD lpMaxCollectionCount,
	446	LPDWORD lpCollectDataTimeout,
	447	LPTSTR lpUserName,
	448	DWORD nMaxUserNameSize);
	449
	450	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	451	LPDWORD lpFlags,
	452	LPDWORD lpOutBufferSize,
	453	LPDWORD lpInBufferSize,
	454	LPDWORD lpMaxInstances);
	455
	456
	457	DWORD HMTransactNamedPipe(HANDLE hPipe,
	458	LPVOID lpvWriteBuf,
	459	DWORD cbWriteBuf,
	460	LPVOID lpvReadBuf,
	461	DWORD cbReadBuf,
	462	LPDWORD lpcbRead,
	463	LPOVERLAPPED lpo);
	464
	465
	466	BOOL HMPeekNamedPipe(HANDLE hPipe,
	467	LPVOID lpvBuffer,
	468	DWORD cbBuffer,
	469	LPDWORD lpcbRead,
	470	LPDWORD lpcbAvail,
	471	LPDWORD lpcbMessage);
	472
[4183]	473	DWORD HMCreateNamedPipe(LPCTSTR lpName,
	474	DWORD dwOpenMode,
[3819]	475	DWORD dwPipeMode,
[4183]	476	DWORD nMaxInstances,
[3819]	477	DWORD nOutBufferSize,
[4183]	478	DWORD nInBufferSize,
[3819]	479	DWORD nDefaultTimeOut,
	480	void* lpSecurityAttributes);
	481
	482	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped);
	483
	484	BOOL HMDisconnectNamedPipe(HANDLE hPipe);
	485
	486	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
	487	LPDWORD lpState,
	488	LPDWORD lpCurInstances,
	489	LPDWORD lpMaxCollectionCount,
	490	LPDWORD lpCollectDataTimeout,
	491	LPTSTR lpUserName,
	492	DWORD nMaxUserNameSize);
	493
	494	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
	495	LPDWORD lpFlags,
	496	LPDWORD lpOutBufferSize,
	497	LPDWORD lpInBufferSize,
	498	LPDWORD lpMaxInstances);
	499
	500	DWORD HMTransactNamedPipe(HANDLE hPipe,
	501	LPVOID lpvWriteBuf,
	502	DWORD cbWriteBuf,
	503	LPVOID lpvReadBuf,
	504	DWORD cbReadBuf,
	505	LPDWORD lpcbRead,
	506	LPOVERLAPPED lpo);
	507
	508	BOOL HMSetNamedPipeHandleState(HANDLE hNamedPipe,
	509	LPDWORD lpdwMode,
	510	LPDWORD lpcbMaxCollect,
	511	LPDWORD lpdwCollectDataTimeout);
	512
	513	BOOL HMCreatePipe(PHANDLE phRead,
	514	PHANDLE phWrite,
[4183]	515	LPSECURITY_ATTRIBUTES lpsa,
[3819]	516	DWORD cbPipe);
	517
[5590]	518
	519	//Mailslot API
	520	HANDLE HMCreateMailslotA(LPCSTR lpName, DWORD nMaxMessageSize,
	521	DWORD lReadTimeout,
	522	LPSECURITY_ATTRIBUTES lpSecurityAttributes);
	523	BOOL HMGetMailslotInfo(HANDLE hMailslot,
	524	LPDWORD lpMaxMessageSize,
	525	LPDWORD lpNextSize,
	526	LPDWORD lpMessageCount,
	527	LPDWORD lpReadTimeout);
	528	BOOL HMSetMailslotInfo(HANDLE hMailslot,
	529	DWORD dwReadTimeout);
	530
[262]	531	#ifdef __cplusplus__
	532	}
	533	#endif
	534
	535	#endif /* _HANDLEMANAGER_H_ */

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

Download in other formats: