Context Navigation

source: trunk/include/HandleManager.h@ 4183

Visit:

Last change on this file since 4183 was 4183, checked in by bird, 25 years ago
Added prototype for HMDeviceIoControl.
File size: 22.0 KB

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

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

Download in other formats: