Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/src/kernel32/old/HandleManager.cpp@ 4540

Visit:

Last change on this file since 4540 was 955, checked in by sandervl, 26 years ago
Backup copy of old kernel32
File size: 97.4 KB

Line
1	/* $Id: HandleManager.cpp,v 1.1 1999-09-15 23:32:48 sandervl Exp $ */
2
3	/*
4	*
5	* Project Odin Software License can be found in LICENSE.TXT
6	*
7	*/
8	/*
9	* Win32 Unified Handle Manager for OS/2
10	*
11	* 1998/02/11 PH Patrick Haller (haller@zebra.fh-weingarten.de)
12	*
13	* @(#) HandleManager.Cpp 1.0.0 1998/02/11 PH start
14	*/
15
16	#undef DEBUG_LOCAL
17	//#define DEBUG_LOCAL
18
19
20	/*****************************************************************************
21	* Remark *
22	*****************************************************************************
23
24	1998/02/11 PH Even overlapped I/O could be simulated by another subsystem
25	thread with a request queue. We'll see if required ...
26
27
28	Flush (flush handle buffer)
29	WaitForSingleObject
30	WaitForMultipleObjects (?)
31
32	1998/02/12 PH IBM and Microsoft disagree about the definition of FILE_TYPE_xxx
33	Interesting, Open32 returns Microsoft's values ...
34
35	1998/02/12 PH Handles should be equipped with a locking mechanism, in particular
36	as we publish a pointer into the handle table via HMHandleQueryHandleData
37
38	*/
39
40
41	/*****************************************************************************
42	* Includes *
43	*****************************************************************************/
44
45	#include <os2win.h>
46	#include <stdlib.h>
47	#include <string.h>
48
49	#include "unicode.h"
50	#include "misc.h"
51
52	#include "HandleManager.H"
53	#include "HMDevice.h"
54	#include "HMOpen32.h"
55	#include "HMEvent.h"
56	#include "HMMutex.h"
57	#include "HMSemaphore.h"
58	#include "HMMMap.h"
59	#include <winconst.h>
60
61	/*****************************************************************************
62	* Defines *
63	*****************************************************************************/
64
65	/* this is the size of our currently static handle table */
66	#define MAX_OS2_HMHANDLES 2048
67
68
69	/*****************************************************************************
70	* Structures *
71	*****************************************************************************/
72
73
74	typedef struct _HMHANDLE
75	{
76	HMDeviceHandler pDeviceHandler; / handler for this pseudo-device */
77	HMHANDLEDATA hmHandleData; /* attributes of the handle */
78	} HMHANDLE, *PHMHANDLE;
79
80
81	typedef struct _HMDEVICE
82	{
83	struct _HMDEVICE pNext; / pointer to next device in chain */
84
85	LPSTR pszDeviceName; /* name or alias of the pseudo-device */
86	HMDeviceHandler pDeviceHandler; / handler for this pseudo-device */
87	} HMDEVICE, *PHMDEVICE;
88
89
90	/*****************************************************************************
91	* This pseudo-device logs all device requests to the logfile and returns *
92	* ERROR_INVALID_FUNCTION to virtually all requests -> debugging *
93	*****************************************************************************/
94	class HMDeviceDebugClass : public HMDeviceHandler
95	{
96	public:
97	HMDeviceDebugClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
98	};
99
100
101	/*****************************************************************************
102	* Process Global Structures *
103	*****************************************************************************/
104
105
106	/* the device name is repeated here to enable device alias names */
107	static PHMDEVICE TabWin32Devices = NULL;
108	static HMHANDLE TabWin32Handles[MAX_OS2_HMHANDLES]; /* static handle table */
109
110
111	struct _HMGlobals
112	{
113	HANDLE hStandardIn; /* stdin handle to CONIN$ */
114	HANDLE hStandardOut; /* stdout handle to CONOUT$ */
115	HANDLE hStandardError; /* stderr handle to CONOUT$ */
116
117	BOOL fIsInitialized; /* if HM is initialized already ? */
118	/* this MUST !!! be false initially */
119
120	HMDeviceHandler pHMOpen32; / default handle manager instance */
121	HMDeviceHandler pHMEvent; / static instances of subsystems */
122	HMDeviceHandler *pHMMutex;
123	HMDeviceHandler *pHMSemaphore;
124	HMDeviceHandler pHMFileMapping; / static instances of subsystems */
125
126	ULONG ulHandleLast; /* index of last used handle */
127	} HMGlobals;
128
129
130	/*****************************************************************************
131	* Local Prototypes *
132	*****************************************************************************/
133
134	/* get appropriate device handler by the device name */
135	static HMDeviceHandler* _Optlink _HMDeviceFind(LPSTR pszDeviceName);
136
137	/* get next free handle from the handle table */
138	static ULONG _Optlink _HMHandleGetFree(void);
139
140	/* get handle table entry from handle */
141	static ULONG _Optlink _HMHandleQuery(HANDLE hHandle);
142
143
144
145	/*****************************************************************************
146	* Name : static HMDeviceHandler * _HMDeviceFind
147	* Purpose : obtain appropriate device handler from the table by searching
148	* for a device name or alias
149	* Parameters: PSZ pszDeviceName
150	* Variables :
151	* Result : HMDeviceHandler * - pointer to the handler object
152	* Remark :
153	* Status :
154	*
155	* Author : Patrick Haller [Wed, 1998/02/11 20:42]
156	*****************************************************************************/
157
158	static HMDeviceHandler *_HMDeviceFind (LPSTR pszDeviceName)
159	{
160	PHMDEVICE pHMDevice; /* iterator over the device table */
161
162	if (pszDeviceName != NULL)
163	for (pHMDevice = TabWin32Devices; /* loop over all devices in the table */
164	pHMDevice != NULL;
165	pHMDevice = pHMDevice->pNext)
166	{
167	if (stricmp(pHMDevice->pszDeviceName, /* case-insensitive search */
168	pszDeviceName) == 0)
169	return (pHMDevice->pDeviceHandler); /* OK, we've found our device */
170	}
171
172	return (HMGlobals.pHMOpen32); /* haven't found anything, return default */
173	}
174
175
176	/*****************************************************************************
177	* Name : static int _HMHandleGetFree
178	* Purpose : get index to first free handle in the handle table
179	* Parameters:
180	* Variables :
181	* Result : int iIndex - index to the table or -1 in case of error
182	* Remark :
183	* Status :
184	*
185	* Author : Patrick Haller [Wed, 1998/02/11 20:43]
186	*****************************************************************************/
187
188	static ULONG _HMHandleGetFree(void)
189	{
190	register ULONG ulLoop;
191
192	for (ulLoop = 1; // @@@PH Note, this is an experimental change
193	// 0L as hHandle is sometimes considered invalid!
194	// this will never return 0l as free handle now.
195	ulLoop < MAX_OS2_HMHANDLES;
196	ulLoop++)
197	{
198	/* free handle found ? */
199	if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle) {
200	TabWin32Handles[ulLoop].hmHandleData.dwUserData = 0;
201	TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
202	return (ulLoop); /* OK, then return it to the caller */
203	}
204	}
205
206	return (INVALID_HANDLE_VALUE); /* haven't found any free handle */
207	}
208
209
210	/*****************************************************************************
211	* Name : static int _HMHandleQuery
212	* Purpose : gets the index of handle table entry as fast as possible from
213	* the specified handle
214	* Parameters: HANDLE hHandle
215	* Variables :
216	* Result : index or -1 in case of error
217	* Remark :
218	* Status :
219	*
220	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
221	*****************************************************************************/
222
223	static ULONG _HMHandleQuery(HANDLE hHandle)
224	{
225	if (hHandle > MAX_OS2_HMHANDLES) /* check the table range */
226	return (INVALID_HANDLE_VALUE); /* nope, ERROR_INVALID_HANDLE */
227
228	/* Oops, invalid handle ! */
229	if (INVALID_HANDLE_VALUE == TabWin32Handles[hHandle].hmHandleData.hHMHandle)
230	return (INVALID_HANDLE_VALUE); /* nope, ERROR_INVALID_HANDLE */
231
232	return ( hHandle); /* OK, we've got our handle index */
233	}
234
235
236	/*****************************************************************************
237	* Name : DWORD HMDeviceRegister
238	* Purpose : register a device with the handle manager
239	* Parameters: PSZ pszDeviceName
240	* HMDeviceHandler *pDeviceHandler
241	* Variables :
242	* Result : API returncode
243	* Remark :
244	* Status :
245	*
246	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
247	*****************************************************************************/
248
249	DWORD HMDeviceRegister(LPSTR pszDeviceName,
250	HMDeviceHandler *pDeviceHandler)
251	{
252	PHMDEVICE pHMDevice; /* our new device to be allocated */
253
254	if ( (pszDeviceName == NULL) \|\| /* check parameters */
255	(pDeviceHandler == NULL) )
256	return (ERROR_INVALID_PARAMETER); /* raise error conditon */
257
258
259	pHMDevice = (PHMDEVICE) malloc (sizeof (HMDEVICE) ); /* allocate memory */
260	if (pHMDevice == NULL) /* check proper allocation */
261	return (ERROR_NOT_ENOUGH_MEMORY); /* signal error */
262
263	pHMDevice->pszDeviceName = strdup(pszDeviceName); /* copy name */
264	if (pHMDevice->pszDeviceName == NULL) /* check proper allocation */
265	{
266	free (pHMDevice); /* free previously allocated memory */
267	return (ERROR_NOT_ENOUGH_MEMORY); /* signal error */
268	}
269
270	pHMDevice->pDeviceHandler = pDeviceHandler; /* store pointer to device */
271	pHMDevice->pNext = TabWin32Devices; /* establish linkage */
272
273	TabWin32Devices = pHMDevice; /* insert new node as root in the list */
274
275	return (NO_ERROR);
276	}
277
278
279	/*****************************************************************************
280	* Name : DWORD HMInitialize
281	* Purpose : Initialize the handlemanager
282	* Parameters: -
283	* Variables : -
284	* Result : always NO_ERROR
285	* Remark : this routine just stores the standard handles in the
286	* internal table within the HandleManager
287	* Status :
288	*
289	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
290	*****************************************************************************/
291
292	DWORD HMInitialize(void)
293	{
294	ULONG ulIndex;
295
296	if (HMGlobals.fIsInitialized != TRUE)
297	{
298	HMGlobals.fIsInitialized = TRUE; /* OK, done */
299
300	// fill handle table
301	for (ulIndex = 0;
302	ulIndex < MAX_OS2_HMHANDLES;
303	ulIndex++)
304	TabWin32Handles[ulIndex].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
305
306	dprintf(("KERNEL32:HandleManager:HMInitialize() storing handles.\n"));
307
308	memset(&HMGlobals, /* zero out the structure first */
309	0,
310	sizeof(HMGlobals));
311
312	/* copy standard handles from OS/2's Open32 Subsystem */
313	HMSetStdHandle(STD_INPUT_HANDLE, GetStdHandle(STD_INPUT_HANDLE));
314	HMSetStdHandle(STD_OUTPUT_HANDLE, GetStdHandle(STD_OUTPUT_HANDLE));
315	HMSetStdHandle(STD_ERROR_HANDLE, GetStdHandle(STD_ERROR_HANDLE));
316
317	/* create handle manager instance for Open32 handles */
318	HMGlobals.pHMOpen32 = new HMDeviceOpen32Class("\\\\.\\");
319	HMGlobals.pHMEvent = new HMDeviceEventClass("\\\\EVENT\\");
320	HMGlobals.pHMMutex = new HMDeviceMutexClass("\\\\MUTEX\\");
321	HMGlobals.pHMSemaphore = new HMDeviceSemaphoreClass("\\\\SEM\\");
322	HMGlobals.pHMFileMapping = new HMDeviceMemMapClass("\\\\MEMMAP\\");
323	}
324	return (NO_ERROR);
325	}
326
327
328	/*****************************************************************************
329	* Name : DWORD HMTerminate
330	* Purpose : Terminate the handlemanager
331	* Parameters:
332	* Variables :
333	* Result :
334	* Remark :
335	* Status :
336	*
337	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
338	*****************************************************************************/
339
340	DWORD HMTerminate(void)
341	{
342	/* @@@PH we could deallocate the device list here */
343
344	delete HMGlobals.pHMOpen32;
345	delete HMGlobals.pHMEvent;
346	delete HMGlobals.pHMMutex;
347	delete HMGlobals.pHMSemaphore;
348	delete HMGlobals.pHMFileMapping;
349
350	return (NO_ERROR);
351	}
352
353
354	/*****************************************************************************/
355	/* handle translation buffer management */
356	/* */
357	/* Since some Win32 applications rely (!) on 16-bit handles, we've got to do */
358	/* 32-bit to 16-bit and vs vsa translation here. */
359	/* Filehandle-based functions should be routed via the handlemanager instead */
360	/* of going to Open32 directly. */
361	/*****************************************************************************/
362
363
364	/*****************************************************************************
365	* Name : DWORD HMHandleAllocate
366	* Purpose : allocate a handle in the translation table
367	* Parameters: PULONG pHandle16 - to return the allocated handle
368	* ULONG hHandle32 - the associated OS/2 handle
369	* Variables :
370	* Result : API returncode
371	* Remark : no parameter checking is done, phHandle may not be invalid
372	* hHandle32 shouldn't be 0
373	* Should be protected with a HM-Mutex !
374	* Status :
375	*
376	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
377	*****************************************************************************/
378
379	DWORD HMHandleAllocate (PULONG phHandle16,
380	ULONG hHandleOS2)
381	{
382	register ULONG ulHandle;
383
384	#ifdef DEBUG_LOCAL
385	dprintf(("KERNEL32: HMHandleAllocate (%08xh,%08xh)\n",
386	phHandle16,
387	hHandleOS2));
388	#endif
389
390	ulHandle = HMGlobals.ulHandleLast; /* get free handle */
391
392	do
393	{
394	/* check if handle is free */
395	if (TabWin32Handles[ulHandle].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
396	{
397	*phHandle16 = ulHandle;
398	TabWin32Handles[ulHandle].hmHandleData.hHMHandle = hHandleOS2;
399	HMGlobals.ulHandleLast = ulHandle; /* to shorten search times */
400
401	return (NO_ERROR); /* OK */
402	}
403
404	ulHandle++; /* skip to next entry */
405
406	if (ulHandle >= MAX_OS2_HMHANDLES) /* check boundary */
407	ulHandle = 1;
408	}
409	while (ulHandle != HMGlobals.ulHandleLast);
410
411	return (ERROR_TOO_MANY_OPEN_FILES); /* OK, we're done */
412	}
413
414
415	/*****************************************************************************
416	* Name : DWORD HMHandleFree
417	* Purpose : free a handle from the translation table
418	* Parameters: ULONG hHandle16 - the handle to be freed
419	* Variables :
420	* Result : API returncode
421	* Remark : no parameter checking is done, hHandle16 MAY NEVER exceed
422	* the MAX_TRANSLATION_HANDLES boundary
423	* Status :
424	*
425	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
426	*****************************************************************************/
427
428	DWORD HMHandleFree (ULONG hHandle16)
429	{
430	ULONG rc; /* API returncode */
431
432	#ifdef DEBUG_LOCAL
433	dprintf(("KERNEL32: HMHandleFree (%08xh)\n",
434	hHandle16));
435	#endif
436
437	rc = HMHandleValidate(hHandle16); /* verify handle */
438	if (rc != NO_ERROR) /* check errors */
439	return (rc); /* raise error condition */
440
441	TabWin32Handles[hHandle16].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
442	/* OK, done */
443
444	return (NO_ERROR);
445	}
446
447
448	/*****************************************************************************
449	* Name : DWORD HMHandleValidate
450	* Purpose : validate a handle through the translation table
451	* Parameters: ULONG hHandle16 - the handle to be verified
452	* Variables :
453	* Result : API returncode
454	* Remark :
455	* Status :
456	*
457	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
458	*****************************************************************************/
459
460	DWORD HMHandleValidate (ULONG hHandle16)
461	{
462	#ifdef DEBUG_LOCAL
463	dprintf(("KERNEL32: HMHandleValidate (%08xh)\n",
464	hHandle16));
465	#endif
466
467	if (hHandle16 >= MAX_OS2_HMHANDLES) /* check boundary */
468	return (ERROR_INVALID_HANDLE); /* raise error condition */
469
470	if (TabWin32Handles[hHandle16].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
471	/* valid ? */
472	return (ERROR_INVALID_HANDLE); /* raise error condition */
473
474	return (NO_ERROR);
475	}
476
477
478	/*****************************************************************************
479	* Name : DWORD HMHandleTranslateToWin
480	* Purpose : translate a 32-bit OS/2 handle to the associated windows handle
481	* Parameters: ULONG hHandle32 - the OS/2 handle
482	* PULONG phHandle16 - the associated windows handle
483	* Variables :
484	* Result : API returncode
485	* Remark :
486	* Status :
487	*
488	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
489	*****************************************************************************/
490
491	DWORD HMHandleTranslateToWin (ULONG hHandleOS2,
492	PULONG phHandle16)
493	{
494	ULONG rc; /* API returncode */
495	register ULONG ulIndex; /* index counter over the table */
496
497	#ifdef DEBUG_LOCAL
498	dprintf(("KERNEL32: HMHandleTranslateToWin (%08xh, %08xh)\n",
499	hHandleOS2,
500	phHandle16));
501	#endif
502
503	for (ulIndex = 1;
504	ulIndex < MAX_OS2_HMHANDLES;
505	ulIndex++)
506	{
507	/* look for the handle */
508	if (TabWin32Handles[ulIndex].hmHandleData.hHMHandle == hHandleOS2)
509	{
510	phHandle16 = ulIndex; / deliver result */
511	return (NO_ERROR); /* OK */
512	}
513	}
514
515	return (ERROR_INVALID_HANDLE); /* raise error condition */
516	}
517
518
519	/*****************************************************************************
520	* Name : DWORD HMHandleTranslateToOS2
521	* Purpose : translate a 16-bit Win32 handle to the associated OS/2 handle
522	* Parameters: ULONG hHandle16 - the windows handle
523	* PULONG phHandle32 - the associated OS/2 handle
524	* Variables :
525	* Result : API returncode
526	* Remark :
527	* Status :
528	*
529	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
530	*****************************************************************************/
531
532	DWORD HMHandleTranslateToOS2 (ULONG hHandle16,
533	PULONG phHandleOS2)
534	{
535	#ifdef DEBUG_LOCAL
536	dprintf(("KERNEL32: HMHandleTranslateToOS2 (%08xh, %08xh)\n",
537	hHandle16,
538	phHandleOS2));
539	#endif
540
541	if (HMHandleValidate(hHandle16) == NO_ERROR) /* verify handle */
542	{
543	*phHandleOS2 = TabWin32Handles[hHandle16].hmHandleData.hHMHandle;
544	return (NO_ERROR);
545	}
546
547	return (ERROR_INVALID_HANDLE); /* raise error condition */
548	}
549
550
551	/*****************************************************************************
552	* Name : DWORD HMHandleTranslateToOS2i
553	* Purpose : translate a 16-bit Win32 handle to the associated OS/2 handle
554	* Parameters: ULONG hHandle16 - the windows handle
555	* Variables :
556	* Result : OS/2 handle
557	* Remark : no checkinf
558	* Status :
559	*
560	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
561	*****************************************************************************/
562
563	DWORD HMHandleTranslateToOS2i (ULONG hHandle16)
564	{
565	#ifdef DEBUG_LOCAL
566	dprintf(("KERNEL32: HMHandleTranslateToOS2i (%08xh)\n",
567	hHandle16));
568	#endif
569
570	return(TabWin32Handles[hHandle16].hmHandleData.hHMHandle);
571	}
572
573
574
575	/*****************************************************************************
576	* Name : HANDLE _HMGetStdHandle
577	* Purpose : replacement for Open32's GetStdHandle function
578	* Parameters: DWORD nStdHandle
579	* Variables :
580	* Result : HANDLE to standard device
581	* Remark :
582	* Status :
583	*
584	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
585	*****************************************************************************/
586
587	HANDLE HMGetStdHandle(DWORD nStdHandle)
588	{
589	switch (nStdHandle)
590	{
591	case STD_INPUT_HANDLE: return (HMGlobals.hStandardIn);
592	case STD_OUTPUT_HANDLE: return (HMGlobals.hStandardOut);
593	case STD_ERROR_HANDLE: return (HMGlobals.hStandardError);
594
595	default:
596	{
597	SetLastError(ERROR_INVALID_PARAMETER); /* set error information */
598	return (INVALID_HANDLE_VALUE); /* raise error condition */
599	}
600	}
601	}
602
603
604	/*****************************************************************************
605	* Name : HANDLE _HMSetStdHandle
606	* Purpose : replacement for Open32's SetStdHandle function
607	* Parameters: DWORD nStdHandle
608	* HANDLE hHandle
609	* Variables :
610	* Result : BOOL fSuccess
611	* Remark :
612	* Status :
613	*
614	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
615	*****************************************************************************/
616
617	BOOL HMSetStdHandle(DWORD nStdHandle,
618	HANDLE hHandle)
619	{
620	switch (nStdHandle)
621	{
622	case STD_INPUT_HANDLE: HMGlobals.hStandardIn = hHandle; return TRUE;
623	case STD_OUTPUT_HANDLE: HMGlobals.hStandardOut = hHandle; return TRUE;
624	case STD_ERROR_HANDLE: HMGlobals.hStandardError = hHandle; return TRUE;
625
626	default:
627	{
628	SetLastError(ERROR_INVALID_PARAMETER); /* set error information */
629	return (FALSE); /* raise error condition */
630	}
631	}
632	}
633
634
635	/*****************************************************************************
636	* Name : HANDLE HMDuplicateHandle
637	* Purpose : replacement for Open32's HMDuplicateHandle function
638	* Parameters:
639	*
640	* Variables :
641	* Result : BOOL fSuccess
642	* Remark :
643	* Status :
644	*
645	* Author : Sander van Leeuwen [Wed, 1999/08/25 15:44]
646	*****************************************************************************/
647
648	BOOL HMDuplicateHandle(HANDLE srcprocess,
649	HANDLE srchandle,
650	HANDLE destprocess,
651	PHANDLE desthandle,
652	DWORD fdwAccess,
653	BOOL fInherit,
654	DWORD fdwOptions)
655	{
656	int iIndex; /* index into the handle table */
657	int iIndexNew; /* index into the handle table */
658	HMDeviceHandler pDeviceHandler; / device handler for this handle */
659	PHMHANDLEDATA pHMHandleData;
660	DWORD rc; /* API return code */
661
662	if(HMHandleValidate(srchandle) != NO_ERROR)
663	{
664	dprintf(("KERNEL32: HMDuplicateHandle: invalid handle %x", srchandle));
665	SetLastError(ERROR_INVALID_HANDLE); /* use this as error message */
666	return FALSE;
667	}
668
669	pDeviceHandler = TabWin32Handles[srchandle].pDeviceHandler; /* device is predefined */
670	iIndexNew = _HMHandleGetFree(); /* get free handle */
671	if (-1 == iIndexNew) /* oops, no free handles ! */
672	{
673	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
674	return FALSE; /* signal error */
675	}
676
677	/* initialize the complete HMHANDLEDATA structure */
678	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
679	pHMHandleData->dwType = TabWin32Handles[srchandle].hmHandleData.dwType;
680	if (fdwOptions & DUPLICATE_SAME_ACCESS)
681	pHMHandleData->dwAccess = TabWin32Handles[srchandle].hmHandleData.dwAccess;
682	else
683	pHMHandleData->dwAccess = fdwAccess;
684
685	pHMHandleData->dwShare = TabWin32Handles[srchandle].hmHandleData.dwShare;
686	pHMHandleData->dwCreation = TabWin32Handles[srchandle].hmHandleData.dwCreation;
687	pHMHandleData->dwFlags = TabWin32Handles[srchandle].hmHandleData.dwFlags;
688	pHMHandleData->lpHandlerData = TabWin32Handles[srchandle].hmHandleData.lpHandlerData;
689
690
691	/* we've got to mark the handle as occupied here, since another device */
692	/* could be created within the device handler -> deadlock */
693
694	/* write appropriate entry into the handle table if open succeeded */
695	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
696	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
697
698	/* call the device handler */
699	rc = pDeviceHandler->DuplicateHandle(&TabWin32Handles[iIndexNew].hmHandleData,
700	srcprocess,
701	&TabWin32Handles[srchandle].hmHandleData,
702	destprocess,
703	desthandle,
704	fdwAccess,
705	fInherit,
706	fdwOptions & ~DUPLICATE_CLOSE_SOURCE);
707
708	//Don't let Open32 close it for us, but do it manually (regardless of error; see SDK docs))
709	if (fdwOptions & DUPLICATE_CLOSE_SOURCE)
710	HMCloseHandle(srchandle);
711
712	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
713	{
714	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
715	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
716	return FALSE; /* signal error */
717	}
718	*desthandle = iIndexNew;
719	return TRUE; /* return valid handle */
720	}
721
722	/*****************************************************************************
723	* Name : HANDLE HMCreateFile
724	* Purpose : Wrapper for the CreateFile() API
725	* Parameters:
726	* Variables :
727	* Result :
728	* Remark : Fix parameters passed to the HMDeviceManager::CreateFile
729	* Supply access mode and share mode validation routines
730	* Status :
731	*
732	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
733	*****************************************************************************/
734
735	HFILE HMCreateFile(LPCSTR lpFileName,
736	DWORD dwDesiredAccess,
737	DWORD dwShareMode,
738	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
739	DWORD dwCreationDisposition,
740	DWORD dwFlagsAndAttributes,
741	HANDLE hTemplateFile)
742	{
743	int iIndex; /* index into the handle table */
744	int iIndexNew; /* index into the handle table */
745	HMDeviceHandler pDeviceHandler; / device handler for this handle */
746	HANDLE hResult;
747	DWORD rc; /* API return code */
748	PHMHANDLEDATA pHMHandleData;
749	HMHANDLEDATA HMHandleTemp; /* temporary buffer for handle data */
750
751	/* create new handle by either lpFileName or hTemplateFile */
752	if (lpFileName == NULL) /* this indicates creation from template */
753	{
754	iIndex = _HMHandleQuery(hTemplateFile); /* query table for template */
755	if (-1 == iIndex) /* this device is unknown to us */
756	{
757	SetLastError (ERROR_INVALID_HANDLE);
758	return INVALID_HANDLE_VALUE;
759	}
760	else
761	{
762	/* to pass to handler */
763	pHMHandleData = &TabWin32Handles[iIndex].hmHandleData;
764	pDeviceHandler = TabWin32Handles[iIndex].pDeviceHandler;
765	}
766	}
767	else
768	{
769	pDeviceHandler = _HMDeviceFind((LPSTR)lpFileName); /* find device */
770
771	if (NULL == pDeviceHandler) /* this name is unknown to us */
772	{
773	SetLastError(ERROR_FILE_NOT_FOUND);
774	return (INVALID_HANDLE_VALUE); /* signal error */
775	}
776	else
777	pHMHandleData = NULL;
778	}
779
780
781	iIndexNew = _HMHandleGetFree(); /* get free handle */
782	if (-1 == iIndexNew) /* oops, no free handles ! */
783	{
784	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
785	return (INVALID_HANDLE_VALUE); /* signal error */
786	}
787
788
789	/* initialize the complete HMHANDLEDATA structure */
790	if (lpFileName == NULL) /* create from template */
791	memcpy (&TabWin32Handles[iIndexNew].hmHandleData,
792	&TabWin32Handles[iIndex].hmHandleData,
793	sizeof(HMHANDLEDATA));
794	else
795	{
796	HMHandleTemp.dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
797	HMHandleTemp.dwAccess = dwDesiredAccess;
798	HMHandleTemp.dwShare = dwShareMode;
799	HMHandleTemp.dwCreation = dwCreationDisposition;
800	HMHandleTemp.dwFlags = dwFlagsAndAttributes;
801	HMHandleTemp.lpHandlerData = NULL;
802	}
803
804	/* we've got to mark the handle as occupied here, since another device */
805	/* could be created within the device handler -> deadlock */
806
807	/* write appropriate entry into the handle table if open succeeded */
808	HMHandleTemp.hHMHandle = iIndexNew;
809	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
810
811	/* now copy back our temporary handle data */
812	memcpy(&TabWin32Handles[iIndexNew].hmHandleData,
813	&HMHandleTemp,
814	sizeof(HMHANDLEDATA));
815
816	rc = pDeviceHandler->CreateFile(lpFileName, /* call the device handler */
817	&HMHandleTemp,
818	lpSecurityAttributes,
819	pHMHandleData);
820
821	#ifdef DEBUG_LOCAL
822	dprintf(("KERNEL32/HandleManager:CheckPoint2: %s lpHandlerData=%08xh\n",
823	lpFileName,
824	HMHandleTemp.lpHandlerData));
825	#endif
826
827	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
828	{
829	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
830	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
831	return (INVALID_HANDLE_VALUE); /* signal error */
832	}
833	else
834	{
835	/* copy data fields that might have been modified by CreateFile */
836	memcpy(&TabWin32Handles[iIndexNew].hmHandleData,
837	&HMHandleTemp,
838	sizeof(HMHANDLEDATA));
839	}
840
841
842	#ifdef DEBUG_LOCAL
843	dprintf(("KERNEL32/HandleManager: CreateFile(%s)=%08xh\n",
844	lpFileName,
845	iIndexNew));
846	#endif
847
848	return (HFILE)iIndexNew; /* return valid handle */
849	}
850
851
852	/*****************************************************************************
853	* Name : HANDLE HMOpenFile
854	* Purpose : Wrapper for the OpenFile() API
855	* Parameters:
856	* Variables :
857	* Result :
858	* Remark : Fix parameters passed to the HMDeviceManager::OpenFile
859	* Supply access mode and share mode validation routines
860	* Status :
861	*
862	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
863	*****************************************************************************/
864
865
866	/***********************************************************************
867	* FILE_ConvertOFMode
868	*
869	* Convert OF_* mode into flags for CreateFile.
870	*/
871	static void FILE_ConvertOFMode( INT mode, DWORD access, DWORD sharing )
872	{
873	switch(mode & 0x03)
874	{
875	case OF_READ: *access = GENERIC_READ; break;
876	case OF_WRITE: *access = GENERIC_WRITE; break;
877	case OF_READWRITE: *access = GENERIC_READ \| GENERIC_WRITE; break;
878	default: *access = 0; break;
879	}
880	switch(mode & 0x70)
881	{
882	case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
883	case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
884	case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
885	case OF_SHARE_DENY_NONE:
886	case OF_SHARE_COMPAT:
887	default: *sharing = FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
888	}
889	}
890
891	HANDLE HMOpenFile(LPCSTR lpFileName,
892	OFSTRUCT* pOFStruct,
893	UINT fuMode)
894	{
895	int iIndex; /* index into the handle table */
896	int iIndexNew; /* index into the handle table */
897	HMDeviceHandler pDeviceHandler; / device handler for this handle */
898	PHMHANDLEDATA pHMHandleData;
899	DWORD rc; /* API return code */
900
901
902	pDeviceHandler = _HMDeviceFind((LPSTR)lpFileName); /* find device */
903	if (NULL == pDeviceHandler) /* this name is unknown to us */
904	{
905	SetLastError(ERROR_FILE_NOT_FOUND);
906	return (INVALID_HANDLE_VALUE); /* signal error */
907	}
908	else
909	pHMHandleData = NULL;
910
911
912	iIndexNew = _HMHandleGetFree(); /* get free handle */
913	if (-1 == iIndexNew) /* oops, no free handles ! */
914	{
915	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
916	return (INVALID_HANDLE_VALUE); /* signal error */
917	}
918
919
920	/* initialize the complete HMHANDLEDATA structure */
921	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
922	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
923
924	FILE_ConvertOFMode(fuMode, /* map OF_flags */
925	&pHMHandleData->dwAccess,
926	&pHMHandleData->dwShare);
927
928	pHMHandleData->dwCreation = 0;
929	pHMHandleData->dwFlags = 0;
930	pHMHandleData->lpHandlerData = NULL;
931
932
933	/* we've got to mark the handle as occupied here, since another device */
934	/* could be created within the device handler -> deadlock */
935
936	/* write appropriate entry into the handle table if open succeeded */
937	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
938	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
939
940	rc = pDeviceHandler->OpenFile (lpFileName, /* call the device handler */
941	&TabWin32Handles[iIndexNew].hmHandleData,
942	pOFStruct,
943	fuMode);
944
945	#ifdef DEBUG_LOCAL
946	dprintf(("KERNEL32/HandleManager:CheckPoint3: %s lpHandlerData=%08xh rc=%08xh\n",
947	lpFileName,
948	&TabWin32Handles[iIndexNew].hmHandleData.lpHandlerData,
949	rc));
950	#endif
951
952	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
953	{
954	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
955	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
956	return (INVALID_HANDLE_VALUE); /* signal error */
957	}
958
959	#ifdef DEBUG_LOCAL
960	dprintf(("KERNEL32/HandleManager: OpenFile(%s)=%08xh\n",
961	lpFileName,
962	hResult));
963	#endif
964
965	return iIndexNew; /* return valid handle */
966	}
967
968
969
970	/*****************************************************************************
971	* Name : HANDLE HMCloseFile
972	* Purpose : Wrapper for the CloseHandle() API
973	* Parameters:
974	* Variables :
975	* Result :
976	* Remark :
977	* Status :
978	*
979	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
980	*****************************************************************************/
981
982	BOOL HMCloseHandle(HANDLE hObject)
983	{
984	int iIndex; /* index into the handle table */
985	BOOL fResult; /* result from the device handler's CloseHandle() */
986	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
987
988	/* validate handle */
989	iIndex = _HMHandleQuery(hObject); /* get the index */
990	if (-1 == iIndex) /* error ? */
991	{
992	//@@@PH it may occur someone closes e.g. a semaphore handle
993	// which is not registered through the HandleManager yet.
994	// so we try to pass on to Open32 instead.
995	dprintf(("KERNEL32: HandleManager:HMCloseHandle(%08xh) passed on to Open32.\n",
996	hObject));
997
998	fResult = O32_CloseHandle(hObject);
999	return (fResult);
1000
1001	//SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1002	//return (FALSE); /* signal failure */
1003	}
1004
1005	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1006	//SvL: Check if pDeviceHandler is set
1007	if (pHMHandle->pDeviceHandler)
1008	{
1009	fResult = pHMHandle->pDeviceHandler->CloseHandle(&pHMHandle->hmHandleData);
1010	}
1011	else
1012	{
1013	dprintf(("HMCloseHAndle(%08xh): pDeviceHandler not set", hObject));
1014	fResult = TRUE;
1015	}
1016
1017	if (fResult == TRUE) /* remove handle if close succeeded */
1018	pHMHandle->hmHandleData.hHMHandle = 0; /* mark handle as free */
1019
1020	return (fResult); /* deliver return code */
1021	}
1022
1023
1024	/*****************************************************************************
1025	* Name : HANDLE HMReadFile
1026	* Purpose : Wrapper for the ReadHandle() API
1027	* Parameters:
1028	* Variables :
1029	* Result :
1030	* Remark :
1031	* Status :
1032	*
1033	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1034	*****************************************************************************/
1035
1036	BOOL HMReadFile(HANDLE hFile,
1037	LPVOID lpBuffer,
1038	DWORD nNumberOfBytesToRead,
1039	LPDWORD lpNumberOfBytesRead,
1040	LPOVERLAPPED lpOverlapped)
1041	{
1042	int iIndex; /* index into the handle table */
1043	BOOL fResult; /* result from the device handler's CloseHandle() */
1044	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1045
1046	/* validate handle */
1047	iIndex = _HMHandleQuery(hFile); /* get the index */
1048	if (-1 == iIndex) /* error ? */
1049	{
1050	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1051	return (FALSE); /* signal failure */
1052	}
1053
1054	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1055	fResult = pHMHandle->pDeviceHandler->ReadFile(&pHMHandle->hmHandleData,
1056	lpBuffer,
1057	nNumberOfBytesToRead,
1058	lpNumberOfBytesRead,
1059	lpOverlapped);
1060
1061	return (fResult); /* deliver return code */
1062	}
1063
1064
1065	/*****************************************************************************
1066	* Name : HANDLE HMWriteFile
1067	* Purpose : Wrapper for the WriteHandle() API
1068	* Parameters:
1069	* Variables :
1070	* Result :
1071	* Remark :
1072	* Status :
1073	*
1074	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1075	*****************************************************************************/
1076
1077	BOOL HMWriteFile(HANDLE hFile,
1078	LPCVOID lpBuffer,
1079	DWORD nNumberOfBytesToWrite,
1080	LPDWORD lpNumberOfBytesWritten,
1081	LPOVERLAPPED lpOverlapped)
1082	{
1083	int iIndex; /* index into the handle table */
1084	BOOL fResult; /* result from the device handler's CloseHandle() */
1085	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1086
1087	/* validate handle */
1088	iIndex = _HMHandleQuery(hFile); /* get the index */
1089	if (-1 == iIndex) /* error ? */
1090	{
1091	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1092	return (FALSE); /* signal failure */
1093	}
1094
1095	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1096	fResult = pHMHandle->pDeviceHandler->WriteFile(&pHMHandle->hmHandleData,
1097	lpBuffer,
1098	nNumberOfBytesToWrite,
1099	lpNumberOfBytesWritten,
1100	lpOverlapped);
1101
1102	return (fResult); /* deliver return code */
1103	}
1104
1105
1106	/*****************************************************************************
1107	* Name : HANDLE HMGetFileType
1108	* Purpose : Wrapper for the GetFileType() API
1109	* Parameters:
1110	* Variables :
1111	* Result :
1112	* Remark :
1113	* Status :
1114	*
1115	* Author : Patrick Haller [Wed, 1998/02/12 13:37]
1116	*****************************************************************************/
1117
1118	DWORD HMGetFileType(HANDLE hFile)
1119	{
1120	int iIndex; /* index into the handle table */
1121	DWORD dwResult; /* result from the device handler's API */
1122	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1123
1124	/* validate handle */
1125	iIndex = _HMHandleQuery(hFile); /* get the index */
1126	if (-1 == iIndex) /* error ? */
1127	{
1128	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1129	return (INVALID_HANDLE_ERROR); /* signal failure */
1130	}
1131
1132	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1133	dwResult = pHMHandle->pDeviceHandler->GetFileType(&pHMHandle->hmHandleData);
1134
1135	return (dwResult); /* deliver return code */
1136	}
1137
1138
1139	/*****************************************************************************
1140	* Name : HMDeviceHandler::_DeviceReuqest
1141	* Purpose : entry method for special request functions
1142	* Parameters: ULONG ulRequestCode
1143	* various parameters as required
1144	* Variables :
1145	* Result :
1146	* Remark : the standard behaviour is to return an error code for non-
1147	* existant request codes
1148	* Status :
1149	*
1150	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1151	*****************************************************************************/
1152
1153	DWORD HMDeviceRequest (HANDLE hFile,
1154	ULONG ulRequestCode,
1155	ULONG arg1,
1156	ULONG arg2,
1157	ULONG arg3,
1158	ULONG arg4)
1159	{
1160	int iIndex; /* index into the handle table */
1161	DWORD dwResult; /* result from the device handler's API */
1162	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1163
1164	/* validate handle */
1165	iIndex = _HMHandleQuery(hFile); /* get the index */
1166	if (-1 == iIndex) /* error ? */
1167	{
1168	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1169	return (INVALID_HANDLE_ERROR); /* signal failure */
1170	}
1171
1172	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1173	dwResult = pHMHandle->pDeviceHandler->_DeviceRequest(&pHMHandle->hmHandleData,
1174	ulRequestCode,
1175	arg1,
1176	arg2,
1177	arg3,
1178	arg4);
1179
1180	return (dwResult); /* deliver return code */
1181	}
1182
1183
1184	/*****************************************************************************
1185	* Name : HMDeviceHandler::GetFileInformationByHandle
1186	* Purpose : router function for GetFileInformationByHandle
1187	* Parameters:
1188	* Variables :
1189	* Result :
1190	* Remark :
1191	* Status :
1192	*
1193	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1194	*****************************************************************************/
1195
1196	BOOL HMGetFileInformationByHandle (HANDLE hFile,
1197	BY_HANDLE_FILE_INFORMATION *pHFI)
1198	{
1199	int iIndex; /* index into the handle table */
1200	DWORD dwResult; /* result from the device handler's API */
1201	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1202
1203	/* validate handle */
1204	iIndex = _HMHandleQuery(hFile); /* get the index */
1205	if (-1 == iIndex) /* error ? */
1206	{
1207	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1208	return (INVALID_HANDLE_ERROR); /* signal failure */
1209	}
1210
1211	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1212	dwResult = pHMHandle->pDeviceHandler->GetFileInformationByHandle(&pHMHandle->hmHandleData,
1213	pHFI);
1214
1215	return (dwResult); /* deliver return code */
1216	}
1217
1218
1219	/*****************************************************************************
1220	* Name : HMDeviceHandler::SetEndOfFile
1221	* Purpose : router function for SetEndOfFile
1222	* Parameters:
1223	* Variables :
1224	* Result :
1225	* Remark :
1226	* Status :
1227	*
1228	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1229	*****************************************************************************/
1230
1231	BOOL HMSetEndOfFile (HANDLE hFile)
1232	{
1233	int iIndex; /* index into the handle table */
1234	BOOL bResult; /* result from the device handler's API */
1235	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1236
1237	/* validate handle */
1238	iIndex = _HMHandleQuery(hFile); /* get the index */
1239	if (-1 == iIndex) /* error ? */
1240	{
1241	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1242	return (INVALID_HANDLE_ERROR); /* signal failure */
1243	}
1244
1245	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1246	bResult = pHMHandle->pDeviceHandler->SetEndOfFile(&pHMHandle->hmHandleData);
1247
1248	return (bResult); /* deliver return code */
1249	}
1250
1251
1252	/*****************************************************************************
1253	* Name : HMDeviceHandler::SetFileTime
1254	* Purpose : router function for SetFileTime
1255	* Parameters:
1256	* Variables :
1257	* Result :
1258	* Remark :
1259	* Status :
1260	*
1261	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1262	*****************************************************************************/
1263
1264	BOOL HMSetFileTime (HANDLE hFile,
1265	const FILETIME *pFT1,
1266	const FILETIME *pFT2,
1267	const FILETIME *pFT3)
1268	{
1269	int iIndex; /* index into the handle table */
1270	BOOL bResult; /* result from the device handler's API */
1271	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1272
1273	/* validate handle */
1274	iIndex = _HMHandleQuery(hFile); /* get the index */
1275	if (-1 == iIndex) /* error ? */
1276	{
1277	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1278	return (INVALID_HANDLE_ERROR); /* signal failure */
1279	}
1280
1281	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1282	bResult = pHMHandle->pDeviceHandler->SetFileTime(&pHMHandle->hmHandleData,
1283	(LPFILETIME)pFT1,
1284	(LPFILETIME)pFT2,
1285	(LPFILETIME)pFT3);
1286
1287	return (bResult); /* deliver return code */
1288	}
1289
1290
1291	/*****************************************************************************
1292	* Name : HMDeviceHandler::GetFileSize
1293	* Purpose : router function for GetFileSize
1294	* Parameters:
1295	* Variables :
1296	* Result :
1297	* Remark :
1298	* Status :
1299	*
1300	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1301	*****************************************************************************/
1302
1303	DWORD HMGetFileSize (HANDLE hFile,
1304	PDWORD pSize)
1305	{
1306	int iIndex; /* index into the handle table */
1307	DWORD dwResult; /* result from the device handler's API */
1308	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1309
1310	/* validate handle */
1311	iIndex = _HMHandleQuery(hFile); /* get the index */
1312	if (-1 == iIndex) /* error ? */
1313	{
1314	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1315	return (INVALID_HANDLE_ERROR); /* signal failure */
1316	}
1317
1318	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1319	dwResult = pHMHandle->pDeviceHandler->GetFileSize(&pHMHandle->hmHandleData,
1320	pSize);
1321
1322	return (dwResult); /* deliver return code */
1323	}
1324
1325
1326	/*****************************************************************************
1327	* Name : HMDeviceHandler::SetFilePointer
1328	* Purpose : router function for SetFilePointer
1329	* Parameters:
1330	* Variables :
1331	* Result :
1332	* Remark :
1333	* Status :
1334	*
1335	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1336	*****************************************************************************/
1337
1338	DWORD HMSetFilePointer (HANDLE hFile,
1339	LONG lDistanceToMove,
1340	PLONG lpDistanceToMoveHigh,
1341	DWORD dwMoveMethod)
1342	{
1343	int iIndex; /* index into the handle table */
1344	DWORD dwResult; /* result from the device handler's API */
1345	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1346
1347	/* validate handle */
1348	iIndex = _HMHandleQuery(hFile); /* get the index */
1349	if (-1 == iIndex) /* error ? */
1350	{
1351	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1352	return (INVALID_HANDLE_ERROR); /* signal failure */
1353	}
1354
1355	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1356	dwResult = pHMHandle->pDeviceHandler->SetFilePointer(&pHMHandle->hmHandleData,
1357	lDistanceToMove,
1358	lpDistanceToMoveHigh,
1359	dwMoveMethod);
1360
1361	return (dwResult); /* deliver return code */
1362	}
1363
1364
1365	/*****************************************************************************
1366	* Name : HMDeviceHandler::LockFile
1367	* Purpose : router function for LockFile
1368	* Parameters:
1369	* Variables :
1370	* Result :
1371	* Remark :
1372	* Status :
1373	*
1374	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1375	*****************************************************************************/
1376
1377	BOOL HMLockFile (HFILE hFile,
1378	DWORD arg2,
1379	DWORD arg3,
1380	DWORD arg4,
1381	DWORD arg5)
1382	{
1383	int iIndex; /* index into the handle table */
1384	DWORD dwResult; /* result from the device handler's API */
1385	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1386
1387	/* validate handle */
1388	iIndex = _HMHandleQuery(hFile); /* get the index */
1389	if (-1 == iIndex) /* error ? */
1390	{
1391	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1392	return (INVALID_HANDLE_ERROR); /* signal failure */
1393	}
1394
1395	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1396	dwResult = pHMHandle->pDeviceHandler->LockFile(&pHMHandle->hmHandleData,
1397	arg2,
1398	arg3,
1399	arg4,
1400	arg5);
1401
1402	return (dwResult); /* deliver return code */
1403	}
1404
1405
1406	/*****************************************************************************
1407	* Name : HMDeviceHandler::LockFileEx
1408	* Purpose : router function for LockFileEx
1409	* Parameters:
1410	* Variables :
1411	* Result :
1412	* Remark :
1413	* Status :
1414	*
1415	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1416	*****************************************************************************/
1417
1418	BOOL HMLockFileEx(HANDLE hFile,
1419	DWORD dwFlags,
1420	DWORD dwReserved,
1421	DWORD nNumberOfBytesToLockLow,
1422	DWORD nNumberOfBytesToLockHigh,
1423	LPOVERLAPPED lpOverlapped)
1424	{
1425	int iIndex; /* index into the handle table */
1426	DWORD dwResult; /* result from the device handler's API */
1427	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1428
1429	/* validate handle */
1430	iIndex = _HMHandleQuery(hFile); /* get the index */
1431	if (-1 == iIndex) /* error ? */
1432	{
1433	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1434	return (INVALID_HANDLE_ERROR); /* signal failure */
1435	}
1436
1437	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1438	dwResult = pHMHandle->pDeviceHandler->LockFileEx(&pHMHandle->hmHandleData,
1439	dwFlags,
1440	dwReserved,
1441	nNumberOfBytesToLockLow,
1442	nNumberOfBytesToLockHigh,
1443	lpOverlapped);
1444
1445	return (dwResult); /* deliver return code */
1446	}
1447
1448
1449
1450	/*****************************************************************************
1451	* Name : HMDeviceHandler::UnlockFile
1452	* Purpose : router function for UnlockFile
1453	* Parameters:
1454	* Variables :
1455	* Result :
1456	* Remark :
1457	* Status :
1458	*
1459	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1460	*****************************************************************************/
1461
1462	BOOL HMUnlockFile (HFILE hFile,
1463	DWORD arg2,
1464	DWORD arg3,
1465	DWORD arg4,
1466	DWORD arg5)
1467	{
1468	int iIndex; /* index into the handle table */
1469	DWORD dwResult; /* result from the device handler's API */
1470	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1471
1472	/* validate handle */
1473	iIndex = _HMHandleQuery(hFile); /* get the index */
1474	if (-1 == iIndex) /* error ? */
1475	{
1476	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1477	return (INVALID_HANDLE_ERROR); /* signal failure */
1478	}
1479
1480	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1481	dwResult = pHMHandle->pDeviceHandler->UnlockFile(&pHMHandle->hmHandleData,
1482	arg2,
1483	arg3,
1484	arg4,
1485	arg5);
1486
1487	return (dwResult); /* deliver return code */
1488	}
1489
1490
1491	/*****************************************************************************
1492	* Name : HMDeviceHandler::UnlockFileEx
1493	* Purpose : router function for UnlockFileEx
1494	* Parameters:
1495	* Variables :
1496	* Result :
1497	* Remark :
1498	* Status :
1499	*
1500	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1501	*****************************************************************************/
1502
1503	BOOL HMUnlockFileEx(HANDLE hFile,
1504	DWORD dwFlags,
1505	DWORD dwReserved,
1506	DWORD nNumberOfBytesToLockLow,
1507	DWORD nNumberOfBytesToLockHigh,
1508	LPOVERLAPPED lpOverlapped)
1509	{
1510	int iIndex; /* index into the handle table */
1511	DWORD dwResult; /* result from the device handler's API */
1512	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1513
1514	/* validate handle */
1515	iIndex = _HMHandleQuery(hFile); /* get the index */
1516	if (-1 == iIndex) /* error ? */
1517	{
1518	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1519	return (INVALID_HANDLE_ERROR); /* signal failure */
1520	}
1521
1522	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1523	dwResult = pHMHandle->pDeviceHandler->UnlockFileEx(&pHMHandle->hmHandleData,
1524	dwFlags,
1525	dwReserved,
1526	nNumberOfBytesToLockLow,
1527	nNumberOfBytesToLockHigh,
1528	lpOverlapped);
1529
1530	return (dwResult); /* deliver return code */
1531	}
1532
1533
1534	/*****************************************************************************
1535	* Name : HMDeviceHandler::WaitForSingleObject
1536	* Purpose : router function for WaitForSingleObject
1537	* Parameters:
1538	* Variables :
1539	* Result :
1540	* Remark :
1541	* Status :
1542	*
1543	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1544	*****************************************************************************/
1545
1546	DWORD HMWaitForSingleObject(HANDLE hObject,
1547	DWORD dwTimeout)
1548	{
1549	int iIndex; /* index into the handle table */
1550	DWORD dwResult; /* result from the device handler's API */
1551	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1552
1553	/* validate handle */
1554	iIndex = _HMHandleQuery(hObject); /* get the index */
1555	if (-1 == iIndex) /* error ? */
1556	{
1557	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1558	return (INVALID_HANDLE_ERROR); /* signal failure */
1559	}
1560
1561	// @@@PH Problem: wrong class (base class) is called instead of
1562	// open32 class ?! Why ?!
1563	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1564	dwResult = pHMHandle->pDeviceHandler->WaitForSingleObject(&pHMHandle->hmHandleData,
1565	dwTimeout);
1566
1567	return (dwResult); /* deliver return code */
1568	}
1569
1570
1571	/*****************************************************************************
1572	* Name : HMDeviceHandler::WaitForSingleObjectEx
1573	* Purpose : router function for WaitForSingleObjectEx
1574	* Parameters:
1575	* Variables :
1576	* Result :
1577	* Remark :
1578	* Status :
1579	*
1580	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1581	*****************************************************************************/
1582
1583	DWORD HMWaitForSingleObjectEx(HANDLE hObject,
1584	DWORD dwTimeout,
1585	BOOL fAlertable)
1586	{
1587	int iIndex; /* index into the handle table */
1588	DWORD dwResult; /* result from the device handler's API */
1589	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1590
1591	/* validate handle */
1592	iIndex = _HMHandleQuery(hObject); /* get the index */
1593	if (-1 == iIndex) /* error ? */
1594	{
1595	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1596	return (INVALID_HANDLE_ERROR); /* signal failure */
1597	}
1598
1599	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1600	dwResult = pHMHandle->pDeviceHandler->WaitForSingleObjectEx(&pHMHandle->hmHandleData,
1601	dwTimeout,
1602	fAlertable);
1603
1604	return (dwResult); /* deliver return code */
1605	}
1606
1607
1608	/*****************************************************************************
1609	* Name : HMDeviceHandler::FlushFileBuffers
1610	* Purpose : router function for FlushFileBuffers
1611	* Parameters:
1612	* Variables :
1613	* Result :
1614	* Remark :
1615	* Status :
1616	*
1617	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1618	*****************************************************************************/
1619
1620	BOOL HMFlushFileBuffers(HANDLE hFile)
1621	{
1622	int iIndex; /* index into the handle table */
1623	DWORD dwResult; /* result from the device handler's API */
1624	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1625
1626	/* validate handle */
1627	iIndex = _HMHandleQuery(hFile); /* get the index */
1628	if (-1 == iIndex) /* error ? */
1629	{
1630	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1631	return (INVALID_HANDLE_ERROR); /* signal failure */
1632	}
1633
1634	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1635	dwResult = pHMHandle->pDeviceHandler->FlushFileBuffers(&pHMHandle->hmHandleData);
1636
1637	return (dwResult); /* deliver return code */
1638	}
1639
1640
1641	/*****************************************************************************
1642	* Name : HMDeviceHandler::GetOverlappedResult
1643	* Purpose : router function for GetOverlappedResult
1644	* Parameters:
1645	* Variables :
1646	* Result :
1647	* Remark :
1648	* Status :
1649	*
1650	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1651	*****************************************************************************/
1652
1653	BOOL HMGetOverlappedResult(HANDLE hObject,
1654	LPOVERLAPPED lpOverlapped,
1655	LPDWORD arg3,
1656	BOOL arg4)
1657	{
1658	int iIndex; /* index into the handle table */
1659	DWORD dwResult; /* result from the device handler's API */
1660	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1661
1662	/* validate handle */
1663	iIndex = _HMHandleQuery(hObject); /* get the index */
1664	if (-1 == iIndex) /* error ? */
1665	{
1666	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1667	return (INVALID_HANDLE_ERROR); /* signal failure */
1668	}
1669
1670	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1671	dwResult = pHMHandle->pDeviceHandler->GetOverlappedResult(&pHMHandle->hmHandleData,
1672	lpOverlapped,
1673	arg3,
1674	arg4);
1675
1676	return (dwResult); /* deliver return code */
1677	}
1678
1679
1680	/*****************************************************************************
1681	* Name : HMReleaseMutex
1682	* Purpose : router function for ReleaseMutex
1683	* Parameters:
1684	* Variables :
1685	* Result :
1686	* Remark :
1687	* Status :
1688	*
1689	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1690	*****************************************************************************/
1691
1692	BOOL HMReleaseMutex(HANDLE hObject)
1693	{
1694	int iIndex; /* index into the handle table */
1695	DWORD dwResult; /* result from the device handler's API */
1696	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1697
1698	/* validate handle */
1699	iIndex = _HMHandleQuery(hObject); /* get the index */
1700	if (-1 == iIndex) /* error ? */
1701	{
1702	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1703	return (INVALID_HANDLE_ERROR); /* signal failure */
1704	}
1705
1706	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1707	dwResult = pHMHandle->pDeviceHandler->ReleaseMutex(&pHMHandle->hmHandleData);
1708
1709	return (dwResult); /* deliver return code */
1710	}
1711
1712
1713	/*****************************************************************************
1714	* Name : HMSetEvent
1715	* Purpose : router function for SetEvent
1716	* Parameters:
1717	* Variables :
1718	* Result :
1719	* Remark :
1720	* Status :
1721	*
1722	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1723	*****************************************************************************/
1724
1725	BOOL HMSetEvent(HANDLE hEvent)
1726	{
1727	int iIndex; /* index into the handle table */
1728	DWORD dwResult; /* result from the device handler's API */
1729	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1730
1731	/* validate handle */
1732	iIndex = _HMHandleQuery(hEvent); /* get the index */
1733	if (-1 == iIndex) /* error ? */
1734	{
1735	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1736	return (INVALID_HANDLE_ERROR); /* signal failure */
1737	}
1738
1739	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1740	dwResult = pHMHandle->pDeviceHandler->SetEvent(&pHMHandle->hmHandleData);
1741
1742	return (dwResult); /* deliver return code */
1743	}
1744
1745
1746	/*****************************************************************************
1747	* Name : HMPulseEvent
1748	* Purpose : router function for PulseEvent
1749	* Parameters:
1750	* Variables :
1751	* Result :
1752	* Remark :
1753	* Status :
1754	*
1755	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1756	*****************************************************************************/
1757
1758	BOOL HMPulseEvent(HANDLE hEvent)
1759	{
1760	int iIndex; /* index into the handle table */
1761	DWORD dwResult; /* result from the device handler's API */
1762	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1763
1764	/* validate handle */
1765	iIndex = _HMHandleQuery(hEvent); /* get the index */
1766	if (-1 == iIndex) /* error ? */
1767	{
1768	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1769	return (INVALID_HANDLE_ERROR); /* signal failure */
1770	}
1771
1772	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1773	dwResult = pHMHandle->pDeviceHandler->PulseEvent(&pHMHandle->hmHandleData);
1774
1775	return (dwResult); /* deliver return code */
1776	}
1777
1778
1779	/*****************************************************************************
1780	* Name : HMResetEvent
1781	* Purpose : router function for ResetEvent
1782	* Parameters:
1783	* Variables :
1784	* Result :
1785	* Remark :
1786	* Status :
1787	*
1788	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1789	*****************************************************************************/
1790
1791	BOOL HMResetEvent(HANDLE hEvent)
1792	{
1793	int iIndex; /* index into the handle table */
1794	DWORD dwResult; /* result from the device handler's API */
1795	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1796
1797	/* validate handle */
1798	iIndex = _HMHandleQuery(hEvent); /* get the index */
1799	if (-1 == iIndex) /* error ? */
1800	{
1801	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1802	return (INVALID_HANDLE_ERROR); /* signal failure */
1803	}
1804
1805	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1806	dwResult = pHMHandle->pDeviceHandler->ResetEvent(&pHMHandle->hmHandleData);
1807
1808	return (dwResult); /* deliver return code */
1809	}
1810
1811
1812	/*****************************************************************************
1813	* Name : HANDLE HMCreateEvent
1814	* Purpose : Wrapper for the CreateEvent() API
1815	* Parameters:
1816	* Variables :
1817	* Result :
1818	* Remark :
1819	* Status :
1820	*
1821	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1822	*****************************************************************************/
1823
1824	HANDLE HMCreateEvent(LPSECURITY_ATTRIBUTES lpsa,
1825	BOOL bManualReset,
1826	BOOL bInitialState,
1827	LPCTSTR lpName)
1828	{
1829	int iIndex; /* index into the handle table */
1830	int iIndexNew; /* index into the handle table */
1831	HMDeviceHandler pDeviceHandler; / device handler for this handle */
1832	PHMHANDLEDATA pHMHandleData;
1833	DWORD rc; /* API return code */
1834
1835
1836	pDeviceHandler = HMGlobals.pHMEvent; /* device is predefined */
1837
1838	iIndexNew = _HMHandleGetFree(); /* get free handle */
1839	if (-1 == iIndexNew) /* oops, no free handles ! */
1840	{
1841	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
1842	return (INVALID_HANDLE_VALUE); /* signal error */
1843	}
1844
1845
1846	/* initialize the complete HMHANDLEDATA structure */
1847	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
1848	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
1849	pHMHandleData->dwAccess = 0;
1850	pHMHandleData->dwShare = 0;
1851	pHMHandleData->dwCreation = 0;
1852	pHMHandleData->dwFlags = 0;
1853	pHMHandleData->lpHandlerData = NULL;
1854
1855
1856	/* we've got to mark the handle as occupied here, since another device */
1857	/* could be created within the device handler -> deadlock */
1858
1859	/* write appropriate entry into the handle table if open succeeded */
1860	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
1861	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
1862
1863	/* call the device handler */
1864	rc = pDeviceHandler->CreateEvent(&TabWin32Handles[iIndexNew].hmHandleData,
1865	lpsa,
1866	bManualReset,
1867	bInitialState,
1868	lpName);
1869	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
1870	{
1871	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1872	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
1873	return (INVALID_HANDLE_VALUE); /* signal error */
1874	}
1875
1876	return iIndexNew; /* return valid handle */
1877	}
1878
1879
1880	/*****************************************************************************
1881	* Name : HANDLE HMCreateMutex
1882	* Purpose : Wrapper for the CreateMutex() API
1883	* Parameters:
1884	* Variables :
1885	* Result :
1886	* Remark :
1887	* Status :
1888	*
1889	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1890	*****************************************************************************/
1891
1892	HANDLE HMCreateMutex(LPSECURITY_ATTRIBUTES lpsa,
1893	BOOL bInitialOwner,
1894	LPCTSTR lpName)
1895	{
1896	int iIndex; /* index into the handle table */
1897	int iIndexNew; /* index into the handle table */
1898	HMDeviceHandler pDeviceHandler; / device handler for this handle */
1899	PHMHANDLEDATA pHMHandleData;
1900	DWORD rc; /* API return code */
1901
1902
1903	pDeviceHandler = HMGlobals.pHMMutex; /* device is predefined */
1904
1905	iIndexNew = _HMHandleGetFree(); /* get free handle */
1906	if (-1 == iIndexNew) /* oops, no free handles ! */
1907	{
1908	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
1909	return (INVALID_HANDLE_VALUE); /* signal error */
1910	}
1911
1912
1913	/* initialize the complete HMHANDLEDATA structure */
1914	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
1915	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
1916	pHMHandleData->dwAccess = 0;
1917	pHMHandleData->dwShare = 0;
1918	pHMHandleData->dwCreation = 0;
1919	pHMHandleData->dwFlags = 0;
1920	pHMHandleData->lpHandlerData = NULL;
1921
1922
1923	/* we've got to mark the handle as occupied here, since another device */
1924	/* could be created within the device handler -> deadlock */
1925
1926	/* write appropriate entry into the handle table if open succeeded */
1927	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
1928	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
1929
1930	/* call the device handler */
1931	rc = pDeviceHandler->CreateMutex(&TabWin32Handles[iIndexNew].hmHandleData,
1932	lpsa,
1933	bInitialOwner,
1934	lpName);
1935	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
1936	{
1937	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1938	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
1939	return (INVALID_HANDLE_VALUE); /* signal error */
1940	}
1941
1942	return iIndexNew; /* return valid handle */
1943	}
1944
1945
1946	/*****************************************************************************
1947	* Name : HANDLE HMOpenEvent
1948	* Purpose : Wrapper for the OpenEvent() API
1949	* Parameters:
1950	* Variables :
1951	* Result :
1952	* Remark :
1953	* Status :
1954	*
1955	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1956	*****************************************************************************/
1957
1958	HANDLE HMOpenEvent(DWORD fdwAccess,
1959	BOOL fInherit,
1960	LPCTSTR lpName)
1961	{
1962	int iIndex; /* index into the handle table */
1963	int iIndexNew; /* index into the handle table */
1964	HMDeviceHandler pDeviceHandler; / device handler for this handle */
1965	PHMHANDLEDATA pHMHandleData;
1966	DWORD rc; /* API return code */
1967
1968
1969	pDeviceHandler = HMGlobals.pHMEvent; /* device is predefined */
1970
1971	iIndexNew = _HMHandleGetFree(); /* get free handle */
1972	if (-1 == iIndexNew) /* oops, no free handles ! */
1973	{
1974	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
1975	return (INVALID_HANDLE_VALUE); /* signal error */
1976	}
1977
1978
1979	/* initialize the complete HMHANDLEDATA structure */
1980	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
1981	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
1982	pHMHandleData->dwAccess = fdwAccess;
1983	pHMHandleData->dwShare = 0;
1984	pHMHandleData->dwCreation = 0;
1985	pHMHandleData->dwFlags = 0;
1986	pHMHandleData->lpHandlerData = NULL;
1987
1988
1989	/* we've got to mark the handle as occupied here, since another device */
1990	/* could be created within the device handler -> deadlock */
1991
1992	/* write appropriate entry into the handle table if open succeeded */
1993	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
1994	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
1995
1996	/* call the device handler */
1997	rc = pDeviceHandler->OpenEvent(&TabWin32Handles[iIndexNew].hmHandleData,
1998	fInherit,
1999	lpName);
2000	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2001	{
2002	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2003	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2004	return (INVALID_HANDLE_VALUE); /* signal error */
2005	}
2006
2007	return iIndexNew; /* return valid handle */
2008	}
2009
2010
2011	/*****************************************************************************
2012	* Name : HANDLE HMOpenMutex
2013	* Purpose : Wrapper for the OpenMutex() API
2014	* Parameters:
2015	* Variables :
2016	* Result :
2017	* Remark :
2018	* Status :
2019	*
2020	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2021	*****************************************************************************/
2022
2023	HANDLE HMOpenMutex(DWORD fdwAccess,
2024	BOOL fInherit,
2025	LPCTSTR lpName)
2026	{
2027	int iIndex; /* index into the handle table */
2028	int iIndexNew; /* index into the handle table */
2029	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2030	PHMHANDLEDATA pHMHandleData;
2031	DWORD rc; /* API return code */
2032
2033
2034	pDeviceHandler = HMGlobals.pHMMutex; /* device is predefined */
2035
2036	iIndexNew = _HMHandleGetFree(); /* get free handle */
2037	if (-1 == iIndexNew) /* oops, no free handles ! */
2038	{
2039	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2040	return (INVALID_HANDLE_VALUE); /* signal error */
2041	}
2042
2043
2044	/* initialize the complete HMHANDLEDATA structure */
2045	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2046	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
2047	pHMHandleData->dwAccess = fdwAccess;
2048	pHMHandleData->dwShare = 0;
2049	pHMHandleData->dwCreation = 0;
2050	pHMHandleData->dwFlags = 0;
2051	pHMHandleData->lpHandlerData = NULL;
2052
2053
2054	/* we've got to mark the handle as occupied here, since another device */
2055	/* could be created within the device handler -> deadlock */
2056
2057	/* write appropriate entry into the handle table if open succeeded */
2058	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2059	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2060
2061	/* call the device handler */
2062	rc = pDeviceHandler->OpenMutex(&TabWin32Handles[iIndexNew].hmHandleData,
2063	fInherit,
2064	lpName);
2065	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2066	{
2067	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2068	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2069	return (INVALID_HANDLE_VALUE); /* signal error */
2070	}
2071
2072	return iIndexNew; /* return valid handle */
2073	}
2074
2075
2076	/*****************************************************************************
2077	* Name : HANDLE HMCreateSemaphore
2078	* Purpose : Wrapper for the CreateSemaphore() API
2079	* Parameters:
2080	* Variables :
2081	* Result :
2082	* Remark :
2083	* Status :
2084	*
2085	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2086	*****************************************************************************/
2087
2088	HANDLE HMCreateSemaphore(LPSECURITY_ATTRIBUTES lpsa,
2089	LONG lInitialCount,
2090	LONG lMaximumCount,
2091	LPCTSTR lpName)
2092	{
2093	int iIndex; /* index into the handle table */
2094	int iIndexNew; /* index into the handle table */
2095	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2096	PHMHANDLEDATA pHMHandleData;
2097	DWORD rc; /* API return code */
2098
2099
2100	pDeviceHandler = HMGlobals.pHMEvent; /* device is predefined */
2101
2102	iIndexNew = _HMHandleGetFree(); /* get free handle */
2103	if (-1 == iIndexNew) /* oops, no free handles ! */
2104	{
2105	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2106	return (INVALID_HANDLE_VALUE); /* signal error */
2107	}
2108
2109
2110	/* initialize the complete HMHANDLEDATA structure */
2111	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2112	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
2113	pHMHandleData->dwAccess = 0;
2114	pHMHandleData->dwShare = 0;
2115	pHMHandleData->dwCreation = 0;
2116	pHMHandleData->dwFlags = 0;
2117	pHMHandleData->lpHandlerData = NULL;
2118
2119
2120	/* we've got to mark the handle as occupied here, since another device */
2121	/* could be created within the device handler -> deadlock */
2122
2123	/* write appropriate entry into the handle table if open succeeded */
2124	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2125	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2126
2127	/* call the device handler */
2128	rc = pDeviceHandler->CreateSemaphore(&TabWin32Handles[iIndexNew].hmHandleData,
2129	lpsa,
2130	lInitialCount,
2131	lMaximumCount,
2132	lpName);
2133	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2134	{
2135	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2136	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2137	return (INVALID_HANDLE_VALUE); /* signal error */
2138	}
2139
2140	return iIndexNew; /* return valid handle */
2141	}
2142
2143
2144	/*****************************************************************************
2145	* Name : HANDLE HMOpenSemaphore
2146	* Purpose : Wrapper for the OpenSemaphore() API
2147	* Parameters:
2148	* Variables :
2149	* Result :
2150	* Remark :
2151	* Status :
2152	*
2153	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2154	*****************************************************************************/
2155
2156	HANDLE HMOpenSemaphore(DWORD fdwAccess,
2157	BOOL fInherit,
2158	LPCTSTR lpName)
2159	{
2160	int iIndex; /* index into the handle table */
2161	int iIndexNew; /* index into the handle table */
2162	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2163	PHMHANDLEDATA pHMHandleData;
2164	DWORD rc; /* API return code */
2165
2166
2167	pDeviceHandler = HMGlobals.pHMMutex; /* device is predefined */
2168
2169	iIndexNew = _HMHandleGetFree(); /* get free handle */
2170	if (-1 == iIndexNew) /* oops, no free handles ! */
2171	{
2172	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2173	return (INVALID_HANDLE_VALUE); /* signal error */
2174	}
2175
2176
2177	/* initialize the complete HMHANDLEDATA structure */
2178	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2179	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
2180	pHMHandleData->dwAccess = fdwAccess;
2181	pHMHandleData->dwShare = 0;
2182	pHMHandleData->dwCreation = 0;
2183	pHMHandleData->dwFlags = 0;
2184	pHMHandleData->lpHandlerData = NULL;
2185
2186
2187	/* we've got to mark the handle as occupied here, since another device */
2188	/* could be created within the device handler -> deadlock */
2189
2190	/* write appropriate entry into the handle table if open succeeded */
2191	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2192	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2193
2194	/* call the device handler */
2195	rc = pDeviceHandler->OpenSemaphore(&TabWin32Handles[iIndexNew].hmHandleData,
2196	fInherit,
2197	lpName);
2198	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2199	{
2200	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2201	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2202	return (INVALID_HANDLE_VALUE); /* signal error */
2203	}
2204
2205	return iIndexNew; /* return valid handle */
2206	}
2207
2208
2209	/*****************************************************************************
2210	* Name : HMReleaseSemaphore
2211	* Purpose : router function for ReleaseSemaphore
2212	* Parameters:
2213	* Variables :
2214	* Result :
2215	* Remark :
2216	* Status :
2217	*
2218	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2219	*****************************************************************************/
2220
2221	BOOL HMReleaseSemaphore(HANDLE hEvent,
2222	LONG cReleaseCount,
2223	LPLONG lpPreviousCount)
2224	{
2225	int iIndex; /* index into the handle table */
2226	DWORD dwResult; /* result from the device handler's API */
2227	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2228
2229	/* validate handle */
2230	iIndex = _HMHandleQuery(hEvent); /* get the index */
2231	if (-1 == iIndex) /* error ? */
2232	{
2233	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2234	return (INVALID_HANDLE_ERROR); /* signal failure */
2235	}
2236
2237	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2238	dwResult = pHMHandle->pDeviceHandler->ReleaseSemaphore(&pHMHandle->hmHandleData,
2239	cReleaseCount,
2240	lpPreviousCount);
2241
2242	return (dwResult); /* deliver return code */
2243	}
2244
2245
2246	/*****************************************************************************
2247	* Name : HANDLE HMCreateFileMapping
2248	* Purpose : Wrapper for the CreateFileMapping() API
2249	* Parameters:
2250	* Variables :
2251	* Result :
2252	* Remark :
2253	* Status :
2254	*
2255	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2256	*****************************************************************************/
2257
2258	HANDLE HMCreateFileMapping(HANDLE hFile,
2259	LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
2260	DWORD flProtect,
2261	DWORD dwMaximumSizeHigh,
2262	DWORD dwMaximumSizeLow,
2263	LPCTSTR lpName)
2264	{
2265	int iIndex; /* index into the handle table */
2266	int iIndexNew; /* index into the handle table */
2267	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2268	PHMHANDLEDATA pHMHandleData;
2269	DWORD rc; /* API return code */
2270
2271
2272	pDeviceHandler = HMGlobals.pHMFileMapping; /* device is predefined */
2273
2274	iIndexNew = _HMHandleGetFree(); /* get free handle */
2275	if (-1 == iIndexNew) /* oops, no free handles ! */
2276	{
2277	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2278	return (INVALID_HANDLE_VALUE); /* signal error */
2279	}
2280
2281
2282	/* initialize the complete HMHANDLEDATA structure */
2283	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2284	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
2285	pHMHandleData->dwAccess = 0;
2286	pHMHandleData->dwShare = 0;
2287	pHMHandleData->dwCreation = 0;
2288	pHMHandleData->dwFlags = 0;
2289	pHMHandleData->lpHandlerData = NULL;
2290
2291
2292	/* we've got to mark the handle as occupied here, since another device */
2293	/* could be created within the device handler -> deadlock */
2294
2295	/* write appropriate entry into the handle table if open succeeded */
2296	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2297	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2298
2299	/* call the device handler */
2300
2301	// @@@PH: Note: hFile is a Win32-style handle, it's not (yet) converted to
2302	// a valid HandleManager-internal handle!
2303	rc = pDeviceHandler->CreateFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
2304	hFile,
2305	lpFileMappingAttributes,
2306	flProtect,
2307	dwMaximumSizeHigh,
2308	dwMaximumSizeLow,
2309	lpName);
2310
2311	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2312	{
2313	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2314	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2315	return (NULL); /* signal error */
2316	}
2317
2318	return iIndexNew; /* return valid handle */
2319	}
2320
2321
2322	/*****************************************************************************
2323	* Name : HANDLE HMOpenFileMapping
2324	* Purpose : Wrapper for the OpenFileMapping() API
2325	* Parameters:
2326	* Variables :
2327	* Result : HANDLE if succeeded,
2328	* NULL if failed.
2329	* Remark :
2330	* Status :
2331	*
2332	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2333	*****************************************************************************/
2334
2335	HANDLE HMOpenFileMapping(DWORD fdwAccess,
2336	BOOL fInherit,
2337	LPCTSTR lpName)
2338	{
2339	int iIndex; /* index into the handle table */
2340	int iIndexNew; /* index into the handle table */
2341	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2342	PHMHANDLEDATA pHMHandleData;
2343	DWORD rc; /* API return code */
2344
2345
2346	pDeviceHandler = HMGlobals.pHMFileMapping; /* device is predefined */
2347
2348	iIndexNew = _HMHandleGetFree(); /* get free handle */
2349	if (-1 == iIndexNew) /* oops, no free handles ! */
2350	{
2351	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2352	return (NULL); /* signal error */
2353	}
2354
2355	/* initialize the complete HMHANDLEDATA structure */
2356	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2357	pHMHandleData->dwType = FILE_TYPE_UNKNOWN; /* unknown handle type */
2358	pHMHandleData->dwAccess = fdwAccess;
2359	pHMHandleData->dwShare = 0;
2360	pHMHandleData->dwCreation = 0;
2361	pHMHandleData->dwFlags = 0;
2362	pHMHandleData->lpHandlerData = NULL;
2363
2364
2365	/* we've got to mark the handle as occupied here, since another device */
2366	/* could be created within the device handler -> deadlock */
2367
2368	/* write appropriate entry into the handle table if open succeeded */
2369	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2370	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2371
2372	/* call the device handler */
2373	rc = pDeviceHandler->OpenFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
2374	fdwAccess,
2375	fInherit,
2376	lpName);
2377	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2378	{
2379	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2380	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2381	return (NULL); /* signal error */
2382	}
2383
2384	return iIndexNew; /* return valid handle */
2385	}
2386
2387
2388	/*****************************************************************************
2389	* Name : HMMapViewOfFileEx
2390	* Purpose : router function for MapViewOfFileEx
2391	* Parameters:
2392	* Variables :
2393	* Result :
2394	* Remark :
2395	* Status :
2396	*
2397	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2398	*****************************************************************************/
2399
2400	LPVOID HMMapViewOfFileEx(HANDLE hFileMappingObject,
2401	DWORD dwDesiredAccess,
2402	DWORD dwFileOffsetHigh,
2403	DWORD dwFileOffsetLow,
2404	DWORD dwNumberOfBytesToMap,
2405	LPVOID lpBaseAddress)
2406	{
2407	int iIndex; /* index into the handle table */
2408	LPVOID lpResult; /* result from the device handler's API */
2409	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2410
2411	/* validate handle */
2412	iIndex = _HMHandleQuery(hFileMappingObject); /* get the index */
2413	if (-1 == iIndex) /* error ? */
2414	{
2415	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2416	return (NULL); /* signal failure */
2417	}
2418
2419	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2420	lpResult = pHMHandle->pDeviceHandler->MapViewOfFileEx(&pHMHandle->hmHandleData,
2421	dwDesiredAccess,
2422	dwFileOffsetHigh,
2423	dwFileOffsetLow,
2424	dwNumberOfBytesToMap,
2425	lpBaseAddress);
2426
2427	return (lpResult); /* deliver return code */
2428	}
2429
2430	/*****************************************************************************
2431	* Name : HMWaitForMultipleObjects
2432	* Purpose : router function for WaitForMultipleObjects
2433	* Parameters:
2434	* Variables :
2435	* Result :
2436	* Remark :
2437	* Status :
2438	*
2439	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2440	*****************************************************************************/
2441
2442	DWORD HMWaitForMultipleObjects (DWORD cObjects,
2443	PHANDLE lphObjects,
2444	BOOL fWaitAll,
2445	DWORD dwTimeout)
2446	{
2447	ULONG ulIndex;
2448	PHANDLE pArrayOfHandles;
2449	PHANDLE pLoop1 = lphObjects;
2450	PHANDLE pLoop2;
2451	DWORD rc;
2452
2453	// allocate array for handle table
2454	pArrayOfHandles = (PHANDLE)malloc(cObjects * sizeof(HANDLE));
2455	if (pArrayOfHandles == NULL)
2456	{
2457	O32_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2458	return WAIT_FAILED;
2459	}
2460	else
2461	pLoop2 = pArrayOfHandles;
2462
2463	// convert array to odin handles
2464	for (ulIndex = 0;
2465
2466	ulIndex < cObjects;
2467
2468	ulIndex++,
2469	pLoop1++,
2470	pLoop2++)
2471	{
2472	rc = HMHandleTranslateToOS2 (*pLoop1, // translate handle
2473	pLoop2);
2474
2475	if (rc != NO_ERROR)
2476	{
2477	free (pArrayOfHandles); // free memory
2478	O32_SetLastError(ERROR_INVALID_HANDLE);
2479	return (WAIT_FAILED);
2480	}
2481	}
2482
2483	// OK, now forward to Open32.
2484	// @@@PH: Note this will fail on handles that do NOT belong to Open32
2485	// but to i.e. the console subsystem!
2486	rc = O32_WaitForMultipleObjects(cObjects,
2487	pArrayOfHandles,
2488	fWaitAll,
2489	dwTimeout);
2490
2491	free(pArrayOfHandles); // free memory
2492	return (rc); // OK, done
2493	}
2494
2495
2496	/*****************************************************************************
2497	* Name : HMWaitForMultipleObjectsEx
2498	* Purpose : router function for WaitForMultipleObjectsEx
2499	* Parameters:
2500	* Variables :
2501	* Result :
2502	* Remark :
2503	* Status :
2504	*
2505	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2506	*****************************************************************************/
2507
2508	DWORD HMWaitForMultipleObjectsEx (DWORD cObjects,
2509	PHANDLE lphObjects,
2510	BOOL fWaitAll,
2511	DWORD dwTimeout,
2512	BOOL fAlertable)
2513	{
2514	// @@@PH: Note: fAlertable is ignored !
2515	return (HMWaitForMultipleObjects(cObjects,
2516	lphObjects,
2517	fWaitAll,
2518	dwTimeout));
2519	}
2520

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

Download in other formats: