Context Navigation

source: trunk/src/kernel32/HandleManager.cpp@ 9022

Visit:

Last change on this file since 9022 was 8952, checked in by sandervl, 23 years ago
Create event semaphore during TEB setup. Used for Post(Thread)Message in combination with MsgWaitForMultipleObjects
File size: 188.8 KB

Line
1	/* $Id: HandleManager.cpp,v 1.90 2002-08-01 16:02:40 sandervl Exp $ */
2
3	/*
4	* Win32 Unified Handle Manager for OS/2
5	*
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	* Project Odin Software License can be found in LICENSE.TXT
11	*
12	*/
13
14	//#undef DEBUG_LOCAL
15	//#define DEBUG_LOCAL
16
17
18	/*****************************************************************************
19	* Remark *
20	*****************************************************************************
21
22	1998/02/11 PH Even overlapped I/O could be simulated by another subsystem
23	thread with a request queue. We'll see if required ...
24
25
26	Flush (flush handle buffer)
27	WaitForSingleObject
28	WaitForMultipleObjects (?)
29
30	1998/02/12 PH IBM and Microsoft disagree about the definition of FILE_TYPE_xxx
31	Interesting, Open32 returns Microsoft's values ...
32
33	1998/02/12 PH Handles should be equipped with a locking mechanism, in particular
34	as we publish a pointer into the handle table via HMHandleQueryHandleData
35
36	*/
37
38
39	/*****************************************************************************
40	* Includes *
41	*****************************************************************************/
42
43	#include <os2win.h>
44	#include <stdlib.h>
45	#include <string.h>
46
47	#include "unicode.h"
48	#include "misc.h"
49
50	#include "HandleManager.H"
51	#include "handlenames.h"
52	#include "HMDevice.h"
53	#include "HMDisk.h"
54	#include "HMOpen32.h"
55	#include "HMEvent.h"
56	#include "HMFile.h"
57	#include "HMMutex.h"
58	#include "HMSemaphore.h"
59	#include "HMMMap.h"
60	#include "HMComm.h"
61	#include "HMParPort.h"
62	#include "HMNul.h"
63	#include "HMToken.h"
64	#include "HMThread.h"
65	#include "HMNPipe.h"
66	#include "HMStd.h"
67	#include "HMMailslot.h"
68
69	#include <vmutex.h>
70	#include <win\thread.h>
71
72	#define DBG_LOCALLOG DBG_handlemanager
73	#include "dbglocal.h"
74
75	/*****************************************************************************
76	* Defines *
77	*****************************************************************************/
78
79	/* this is the size of our currently static handle table */
80	#define MAX_OS2_HMHANDLES 4096
81
82
83	/*****************************************************************************
84	* Structures *
85	*****************************************************************************/
86
87	typedef struct _HMHANDLE
88	{
89	HMDeviceHandler pDeviceHandler; / handler for this pseudo-device */
90	HMHANDLEDATA hmHandleData; /* attributes of the handle */
91	} HMHANDLE, *PHMHANDLE;
92
93
94	typedef struct _HMDEVICE
95	{
96	struct _HMDEVICE pNext; / pointer to next device in chain */
97
98	LPSTR pszDeviceName; /* name or alias of the pseudo-device */
99	HMDeviceHandler pDeviceHandler; / handler for this pseudo-device */
100	VOID pDevData; / Pointer To Device data */
101	} HMDEVICE, *PHMDEVICE;
102
103
104	/*****************************************************************************
105	* This pseudo-device logs all device requests to the logfile and returns *
106	* ERROR_INVALID_FUNCTION to virtually all requests -> debugging *
107	*****************************************************************************/
108	class HMDeviceDebugClass : public HMDeviceHandler
109	{
110	public:
111	HMDeviceDebugClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
112	};
113
114
115	/*****************************************************************************
116	* Process Global Structures *
117	*****************************************************************************/
118
119
120	/* the device name is repeated here to enable device alias names */
121	static PHMDEVICE TabWin32Devices = NULL;
122
123	static HMHANDLE TabWin32Handles = NULL; / static handle table */
124	VMutex handleMutex;
125
126	struct _HMGlobals
127	{
128	HANDLE hStandardIn; /* stdin handle to CONIN$ */
129	HANDLE hStandardOut; /* stdout handle to CONOUT$ */
130	HANDLE hStandardError; /* stderr handle to CONOUT$ */
131
132	BOOL fIsInitialized; /* if HM is initialized already ? */
133	/* this MUST !!! be false initially */
134
135	HMDeviceHandler pHMStandard; / default handle manager instance */
136	HMDeviceHandler pHMOpen32; / default handle manager instance */
137	HMDeviceHandler pHMEvent; / static instances of subsystems */
138	HMDeviceHandler *pHMFile;
139	HMDeviceHandler *pHMDisk;
140	HMDeviceHandler *pHMMutex;
141	HMDeviceHandler *pHMSemaphore;
142	HMDeviceHandler pHMFileMapping; / static instances of subsystems */
143	HMDeviceHandler pHMComm; / serial communication */
144	HMDeviceHandler pHMToken; / security tokens */
145	HMDeviceHandler *pHMThread;
146	HMDeviceHandler *pHMNamedPipe;
147	HMDeviceHandler *pHMMailslot;
148	HMDeviceHandler pHMParPort; / parallel communication */
149	HMDeviceHandler pHMNul; / nul device */
150
151	ULONG ulHandleLast; /* index of last used handle */
152	} HMGlobals;
153
154
155	/*****************************************************************************
156	* Local Prototypes *
157	*****************************************************************************/
158
159	/* get appropriate device handler by the device name */
160	static HMDeviceHandler* _Optlink _HMDeviceFind(LPSTR pszDeviceName);
161
162	/* get next free handle from the handle table */
163	static ULONG _Optlink _HMHandleGetFree(void);
164
165	/* get handle table entry from handle */
166	static ULONG _Optlink _HMHandleQuery(HANDLE hHandle);
167
168	// Get GlobalDeviceData
169	static VOID *_HMDeviceGetData (LPSTR pszDeviceName);
170
171
172	/*****************************************************************************
173	* Name : static HMDeviceHandler * _HMDeviceFind
174	* Purpose : obtain appropriate device handler from the table by searching
175	* for a device name or alias
176	* Parameters: PSZ pszDeviceName
177	* Variables :
178	* Result : HMDeviceHandler * - pointer to the handler object
179	* Remark :
180	* Status :
181	*
182	* Author : Patrick Haller [Wed, 1998/02/11 20:42]
183	*****************************************************************************/
184
185	static HMDeviceHandler *_HMDeviceFind (LPSTR pszDeviceName)
186	{
187	PHMDEVICE pHMDevice; /* iterator over the device table */
188	int namelength = strlen(pszDeviceName);
189
190	if (pszDeviceName != NULL)
191	{
192	for (pHMDevice = TabWin32Devices; /* loop over all devices in the table */
193	pHMDevice != NULL;
194	pHMDevice = pHMDevice->pNext)
195	{
196	if(pHMDevice->pDeviceHandler->FindDevice(pHMDevice->pszDeviceName, pszDeviceName, namelength) == TRUE)
197	{
198	return pHMDevice->pDeviceHandler;
199	}
200	}
201	}
202	return (HMGlobals.pHMOpen32); /* haven't found anything, return default */
203	}
204	/*****************************************************************************
205	* Name : static VOID *_HMDeviceGetData
206	* Purpose : obtain pointer to device data from the table by searching
207	* for a device name or alias
208	* Parameters: PSZ pszDeviceName
209	* Variables :
210	* Result : VOID * - pointer to the handlers device data
211	* Remark :
212	* Status :
213	*
214	* Author : Markus Montkowski
215	*****************************************************************************/
216
217	static VOID *_HMDeviceGetData (LPSTR pszDeviceName)
218	{
219	PHMDEVICE pHMDevice; /* iterator over the device table */
220	int namelength = strlen(pszDeviceName);
221
222	if (pszDeviceName != NULL)
223	{
224	for (pHMDevice = TabWin32Devices; /* loop over all devices in the table */
225	pHMDevice != NULL;
226	pHMDevice = pHMDevice->pNext)
227	{
228	if(pHMDevice->pDeviceHandler->FindDevice(pHMDevice->pszDeviceName, pszDeviceName, namelength) == TRUE)
229	{
230	return (pHMDevice->pDevData); /* OK, we've found our device */
231	}
232	}
233	}
234	return (NULL); /* haven't found anything, return NULL */
235	}
236
237	/*****************************************************************************
238	* Name : static int _HMHandleGetFree
239	* Purpose : get index to first free handle in the handle table
240	* Parameters:
241	* Variables :
242	* Result : int iIndex - index to the table or -1 in case of error
243	* Remark :
244	* Status :
245	*
246	* Author : Patrick Haller [Wed, 1998/02/11 20:43]
247	*****************************************************************************/
248
249	static ULONG _HMHandleGetFree(void)
250	{
251	register ULONG ulLoop;
252
253	handleMutex.enter();
254
255	for (ulLoop = 1; // @@@PH Note, this is an experimental change
256	// 0L as hHandle is sometimes considered invalid!
257	// this will never return 0l as free handle now.
258	ulLoop < MAX_OS2_HMHANDLES;
259	ulLoop++)
260	{
261	/* free handle found ? */
262	if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle) {
263	//SvL: Mark handle as allocated here. Doing it outside of this function
264	// isn't thread safe. (and not very smart)
265	TabWin32Handles[ulLoop].hmHandleData.hHMHandle = ulLoop;
266	TabWin32Handles[ulLoop].hmHandleData.dwUserData = 0;
267	TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
268	TabWin32Handles[ulLoop].hmHandleData.hWin32Handle = (HANDLE)ulLoop;
269	TabWin32Handles[ulLoop].hmHandleData.lpDeviceData = NULL;
270	handleMutex.leave();
271	return (ulLoop); /* OK, then return it to the caller */
272	}
273	}
274
275	handleMutex.leave();
276	return (INVALID_HANDLE_VALUE); /* haven't found any free handle */
277	}
278
279
280	/*****************************************************************************
281	* Name : HMHandleGetUserData
282	* Purpose : Get the dwUserData dword for a specific handle
283	* Parameters: HANDLE hHandle
284	* Variables :
285	* Result : -1 or dwUserData
286	* Remark :
287	* Status :
288	*
289	* Author : SvL
290	*****************************************************************************/
291	DWORD HMHandleGetUserData(ULONG hHandle)
292	{
293	if (hHandle > MAX_OS2_HMHANDLES) /* check the table range */
294	return (-1);
295	/* Oops, invalid handle ! */
296	if (INVALID_HANDLE_VALUE == TabWin32Handles[hHandle].hmHandleData.hHMHandle)
297	return (-1); /* nope, ERROR_INVALID_HANDLE */
298
299	return TabWin32Handles[hHandle].hmHandleData.dwUserData;
300	}
301
302	/*****************************************************************************
303	* Name : HMHandleGetUserData
304	* Purpose : Get the dwUserData dword for a specific handle
305	* Parameters: HANDLE hHandle
306	* Variables :
307	* Result : -1 or dwUserData
308	* Remark :
309	* Status :
310	*
311	* Author : SvL
312	*****************************************************************************/
313	DWORD HMHandleSetUserData(ULONG hHandle, ULONG dwUserData)
314	{
315	if (hHandle > MAX_OS2_HMHANDLES) /* check the table range */
316	return (-1);
317	/* Oops, invalid handle ! */
318	if (INVALID_HANDLE_VALUE == TabWin32Handles[hHandle].hmHandleData.hHMHandle)
319	return (-1); /* nope, ERROR_INVALID_HANDLE */
320
321	TabWin32Handles[hHandle].hmHandleData.dwUserData = dwUserData;
322	return NO_ERROR;
323	}
324
325	/*****************************************************************************
326	* Name : static int _HMHandleQuery
327	* Purpose : gets the index of handle table entry as fast as possible from
328	* the specified handle
329	* Parameters: HANDLE hHandle
330	* Variables :
331	* Result : index or -1 in case of error
332	* Remark : Should fail for standard handles (in/out/err)!!!!!!!!!!
333	* HMGetFileType depends on this!!!
334	* Status :
335	*
336	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
337	*****************************************************************************/
338
339	static ULONG INLINE _HMHandleQuery(HANDLE hHandle)
340	{
341	if (hHandle > MAX_OS2_HMHANDLES) /* check the table range */
342	return (INVALID_HANDLE_VALUE); /* nope, ERROR_INVALID_HANDLE */
343
344	/* Oops, invalid handle ! */
345	if (INVALID_HANDLE_VALUE == TabWin32Handles[hHandle].hmHandleData.hHMHandle)
346	return (INVALID_HANDLE_VALUE); /* nope, ERROR_INVALID_HANDLE */
347
348	return ( hHandle); /* OK, we've got our handle index */
349	}
350
351
352	/*****************************************************************************
353	* Name : DWORD HMDeviceRegister
354	* Purpose : register a device with the handle manager
355	* Parameters: PSZ pszDeviceName
356	* HMDeviceHandler *pDeviceHandler
357	* Variables :
358	* Result : API returncode
359	* Remark :
360	* Status :
361	*
362	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
363	*****************************************************************************/
364
365	DWORD HMDeviceRegisterEx(LPSTR pszDeviceName,
366	HMDeviceHandler *pDeviceHandler,
367	VOID *pDevData)
368	{
369	PHMDEVICE pHMDevice; /* our new device to be allocated */
370
371	if ( (pszDeviceName == NULL) \|\| /* check parameters */
372	(pDeviceHandler == NULL) )
373	return (ERROR_INVALID_PARAMETER); /* raise error conditon */
374
375
376	pHMDevice = (PHMDEVICE) malloc (sizeof (HMDEVICE) ); /* allocate memory */
377	if (pHMDevice == NULL) /* check proper allocation */
378	return (ERROR_NOT_ENOUGH_MEMORY); /* signal error */
379
380	pHMDevice->pszDeviceName = strdup(pszDeviceName); /* copy name */
381	if (pHMDevice->pszDeviceName == NULL) /* check proper allocation */
382	{
383	free (pHMDevice); /* free previously allocated memory */
384	return (ERROR_NOT_ENOUGH_MEMORY); /* signal error */
385	}
386
387	pHMDevice->pDeviceHandler = pDeviceHandler; /* store pointer to device */
388	pHMDevice->pNext = TabWin32Devices; /* establish linkage */
389	pHMDevice->pDevData = pDevData;
390
391	TabWin32Devices = pHMDevice; /* insert new node as root in the list */
392
393	return (NO_ERROR);
394	}
395
396	DWORD HMDeviceRegister(LPSTR pszDeviceName,
397	HMDeviceHandler *pDeviceHandler)
398	{
399	return HMDeviceRegisterEx(pszDeviceName, pDeviceHandler, NULL);
400	}
401
402	/*****************************************************************************
403	* Name : DWORD HMInitialize
404	* Purpose : Initialize the handlemanager
405	* Parameters: -
406	* Variables : -
407	* Result : always NO_ERROR
408	* Remark : this routine just stores the standard handles in the
409	* internal table within the HandleManager
410	* Status :
411	*
412	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
413	*****************************************************************************/
414
415	DWORD HMInitialize(void)
416	{
417	ULONG ulIndex;
418
419	if (HMGlobals.fIsInitialized != TRUE)
420	{
421	handleMutex.enter();
422
423	TabWin32Handles = (HMHANDLE )malloc(MAX_OS2_HMHANDLESsizeof(HMHANDLE));
424	if(TabWin32Handles == NULL) {
425	DebugInt3();
426	return ERROR_NOT_ENOUGH_MEMORY;
427	}
428	memset(TabWin32Handles, 0, MAX_OS2_HMHANDLES*sizeof(HMHANDLE));
429
430	// fill handle table
431	for(ulIndex = 0; ulIndex < MAX_OS2_HMHANDLES; ulIndex++) {
432	TabWin32Handles[ulIndex].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
433	}
434	handleMutex.leave();
435
436	dprintf(("KERNEL32:HandleManager:HMInitialize() storing handles.\n"));
437
438	memset(&HMGlobals, /* zero out the structure first */
439	0,
440	sizeof(HMGlobals));
441
442	HMGlobals.fIsInitialized = TRUE; /* OK, done */
443
444	#if 1
445	//This is a very bad idea. \\\\.\\NTICE -> NTICE, if the file exits, then
446	//it will open the file instead of the device driver
447	/* add standard symbolic links first, so local symbolic links in the
448	* device handlers get precedence over the default here.
449	*
450	* Device handlers are supposed to place the appropriate
451	* symbolic links such as "\\.\\COM1", "COM1"
452	*
453	* - "\\.\f:\temp\readme.txt" is a valid file
454	* - "com1" is a valid device in case serial port 1 exists,
455	* otherwise it'd be a valid file.
456	* - "\\.\filename" is the only misleading case (to be verified)
457	*
458	* Note:
459	* the Open32 "device" definately MUST be the last device to be
460	* asked to accept the specified name.
461	*/
462	{
463	// strings are placed in read-only segment
464	PSZ pszDrive = strdup("\\\\.\\x:");
465	PSZ pszDrive2 = strdup("\\\\.\\x:");
466	for (char ch = 'A'; ch <= 'Z'; ch++)
467	{
468	pszDrive[4] = ch;
469	pszDrive2[4] = ch;
470	HandleNamesAddSymbolicLink(pszDrive, pszDrive+4);
471	HandleNamesAddSymbolicLink(pszDrive2, pszDrive2+4);
472	}
473	free(pszDrive);
474	free(pszDrive2);
475	HandleNamesAddSymbolicLink("\\\\?\\UNC\\", "\\\\");
476	//SvL: Can be used in Windows 2000 to open device drivers
477	HandleNamesAddSymbolicLink("\\\\.\\Global", "\\\\.");
478	}
479	#endif
480
481	/* copy standard handles from OS/2's Open32 Subsystem */
482	HMGlobals.pHMStandard = new HMDeviceStandardClass("\\\\STANDARD_HANDLE\\");
483	HMSetStdHandle(STD_INPUT_HANDLE, O32_GetStdHandle(STD_INPUT_HANDLE));
484	HMSetStdHandle(STD_OUTPUT_HANDLE, O32_GetStdHandle(STD_OUTPUT_HANDLE));
485	HMSetStdHandle(STD_ERROR_HANDLE, O32_GetStdHandle(STD_ERROR_HANDLE));
486
487	/* create handle manager instance for Open32 handles */
488	HMGlobals.pHMOpen32 = new HMDeviceOpen32Class("\\\\.\\");
489	HMGlobals.pHMEvent = new HMDeviceEventClass("\\\\EVENT\\");
490	HMGlobals.pHMFile = new HMDeviceFileClass("\\\\FILE\\");
491	HMGlobals.pHMDisk = new HMDeviceDiskClass("\\\\DISK\\");
492	HMGlobals.pHMMutex = new HMDeviceMutexClass("\\\\MUTEX\\");
493	HMGlobals.pHMSemaphore = new HMDeviceSemaphoreClass("\\\\SEM\\");
494	HMGlobals.pHMFileMapping= new HMDeviceMemMapClass("\\\\MEMMAP\\");
495	HMGlobals.pHMComm = new HMDeviceCommClass("\\\\COM\\");
496	HMGlobals.pHMToken = new HMDeviceTokenClass("\\\\TOKEN\\");
497	HMGlobals.pHMThread = new HMDeviceThreadClass("\\\\THREAD\\");
498	HMGlobals.pHMNamedPipe = new HMDeviceNamedPipeClass("\\\\PIPE\\");
499	HMGlobals.pHMMailslot = new HMMailslotClass("\\MAILSLOT\\");
500	HMGlobals.pHMParPort = new HMDeviceParPortClass("\\\\LPT\\");
501	HMGlobals.pHMNul = new HMDeviceNulClass("\\\\NUL\\");
502	}
503	return (NO_ERROR);
504	}
505
506
507	/*****************************************************************************
508	* Name : DWORD HMTerminate
509	* Purpose : Terminate the handlemanager
510	* Parameters:
511	* Variables :
512	* Result :
513	* Remark :
514	* Status :
515	*
516	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
517	*****************************************************************************/
518
519	DWORD HMTerminate(void)
520	{
521	/* @@@PH we could deallocate the device list here */
522
523	if(HMGlobals.pHMOpen32)
524	delete HMGlobals.pHMOpen32;
525	if(HMGlobals.pHMEvent)
526	delete HMGlobals.pHMEvent;
527	if(HMGlobals.pHMFile)
528	delete HMGlobals.pHMFile;
529	if(HMGlobals.pHMMutex)
530	delete HMGlobals.pHMMutex;
531	if(HMGlobals.pHMSemaphore)
532	delete HMGlobals.pHMSemaphore;
533	if(HMGlobals.pHMFileMapping)
534	delete HMGlobals.pHMFileMapping;
535	if(HMGlobals.pHMComm)
536	delete HMGlobals.pHMComm;
537	if(HMGlobals.pHMToken)
538	delete HMGlobals.pHMToken;
539	if(HMGlobals.pHMThread)
540	delete HMGlobals.pHMThread;
541	if(HMGlobals.pHMNamedPipe)
542	delete HMGlobals.pHMNamedPipe;
543	if(HMGlobals.pHMMailslot)
544	delete HMGlobals.pHMMailslot;
545	if(HMGlobals.pHMDisk)
546	delete HMGlobals.pHMDisk;
547	if(HMGlobals.pHMStandard);
548	delete HMGlobals.pHMStandard;
549	if(HMGlobals.pHMParPort)
550	delete HMGlobals.pHMParPort;
551	if(HMGlobals.pHMNul)
552	delete HMGlobals.pHMNul;
553
554	return (NO_ERROR);
555	}
556
557
558	/*****************************************************************************/
559	/* handle translation buffer management */
560	/* */
561	/* Since some Win32 applications rely (!) on 16-bit handles, we've got to do */
562	/* 32-bit to 16-bit and vs vsa translation here. */
563	/* Filehandle-based functions should be routed via the handlemanager instead */
564	/* of going to Open32 directly. */
565	/*****************************************************************************/
566
567
568	/*****************************************************************************
569	* Name : DWORD HMHandleAllocate
570	* Purpose : allocate a handle in the translation table
571	* Parameters: PULONG pHandle16 - to return the allocated handle
572	* ULONG hHandle32 - the associated OS/2 handle
573	* Variables :
574	* Result : API returncode
575	* Remark : no parameter checking is done, phHandle may not be invalid
576	* hHandle32 shouldn't be 0
577	* Should be protected with a HM-Mutex !
578	* Status :
579	*
580	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
581	*****************************************************************************/
582
583	DWORD HMHandleAllocate (PULONG phHandle16,
584	ULONG hHandleOS2)
585	{
586	register ULONG ulHandle;
587
588	#ifdef DEBUG_LOCAL
589	dprintf(("KERNEL32: HMHandleAllocate (%08xh,%08xh)\n",
590	phHandle16,
591	hHandleOS2));
592	#endif
593
594	// @@@PH 2001-09-27
595	// prevent too quick re-use of last handle
596	ulHandle = HMGlobals.ulHandleLast + 1; /* get free handle */
597
598	handleMutex.enter();
599
600	if(ulHandle == 0) {
601	ulHandle = 1; //SvL: Start searching from index 1
602	}
603	do
604	{
605	/* check if handle is free */
606	if (TabWin32Handles[ulHandle].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
607	{
608	*phHandle16 = ulHandle;
609	TabWin32Handles[ulHandle].hmHandleData.hHMHandle = hHandleOS2;
610	TabWin32Handles[ulHandle].hmHandleData.lpDeviceData = NULL;
611	HMGlobals.ulHandleLast = ulHandle; /* to shorten search times */
612
613	handleMutex.leave();
614	return (NO_ERROR); /* OK */
615	}
616
617	ulHandle++; /* skip to next entry */
618
619	if (ulHandle >= MAX_OS2_HMHANDLES) /* check boundary */
620	ulHandle = 1;
621	}
622	while (ulHandle != HMGlobals.ulHandleLast);
623
624	handleMutex.leave();
625
626	return (ERROR_TOO_MANY_OPEN_FILES); /* OK, we're done */
627	}
628
629
630	/*****************************************************************************
631	* Name : DWORD HMHandleFree
632	* Purpose : free a handle from the translation table
633	* Parameters: ULONG hHandle16 - the handle to be freed
634	* Variables :
635	* Result : API returncode
636	* Remark : no parameter checking is done, hHandle16 MAY NEVER exceed
637	* the MAX_TRANSLATION_HANDLES boundary
638	* Status :
639	*
640	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
641	*****************************************************************************/
642
643	DWORD HMHandleFree (ULONG hHandle16)
644	{
645	ULONG rc; /* API returncode */
646
647	#ifdef DEBUG_LOCAL
648	dprintf(("KERNEL32: HMHandleFree (%08xh)\n",
649	hHandle16));
650	#endif
651
652	rc = HMHandleValidate(hHandle16); /* verify handle */
653	if (rc != NO_ERROR) /* check errors */
654	return (rc); /* raise error condition */
655
656	TabWin32Handles[hHandle16].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
657	/* OK, done */
658
659	return (NO_ERROR);
660	}
661
662
663	/*****************************************************************************
664	* Name : DWORD HMHandleValidate
665	* Purpose : validate a handle through the translation table
666	* Parameters: ULONG hHandle16 - the handle to be verified
667	* Variables :
668	* Result : API returncode
669	* Remark :
670	* Status :
671	*
672	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
673	*****************************************************************************/
674
675	DWORD HMHandleValidate (ULONG hHandle16)
676	{
677	#ifdef DEBUG_LOCAL
678	dprintf(("KERNEL32: HMHandleValidate (%08xh)\n",
679	hHandle16));
680	#endif
681
682	if (hHandle16 >= MAX_OS2_HMHANDLES) /* check boundary */
683	return (ERROR_INVALID_HANDLE); /* raise error condition */
684
685	if (TabWin32Handles[hHandle16].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
686	/* valid ? */
687	return (ERROR_INVALID_HANDLE); /* raise error condition */
688
689	return (NO_ERROR);
690	}
691	//*****************************************************************************
692	//*****************************************************************************
693	PHMHANDLEDATA HMQueryHandleData(HANDLE handle)
694	{
695	int iIndex;
696
697	iIndex = _HMHandleQuery(handle); /* get the index */
698	if (-1 == iIndex) /* error ? */
699	{
700	return NULL;
701	}
702	return &TabWin32Handles[iIndex].hmHandleData; /* call device handler */
703	}
704
705	/*****************************************************************************
706	* Name : DWORD HMHandleTranslateToWin
707	* Purpose : translate a 32-bit OS/2 handle to the associated windows handle
708	* Parameters: ULONG hHandle32 - the OS/2 handle
709	* PULONG phHandle16 - the associated windows handle
710	* Variables :
711	* Result : API returncode
712	* Remark :
713	* Status :
714	*
715	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
716	*****************************************************************************/
717
718	DWORD HMHandleTranslateToWin (ULONG hHandleOS2,
719	PULONG phHandle16)
720	{
721	ULONG rc; /* API returncode */
722	register ULONG ulIndex; /* index counter over the table */
723
724	#ifdef DEBUG_LOCAL
725	dprintf(("KERNEL32: HMHandleTranslateToWin (%08xh, %08xh)\n",
726	hHandleOS2,
727	phHandle16));
728	#endif
729
730	for (ulIndex = 1;
731	ulIndex < MAX_OS2_HMHANDLES;
732	ulIndex++)
733	{
734	/* look for the handle */
735	if (TabWin32Handles[ulIndex].hmHandleData.hHMHandle == hHandleOS2)
736	{
737	phHandle16 = ulIndex; / deliver result */
738	return (NO_ERROR); /* OK */
739	}
740	}
741
742	return (ERROR_INVALID_HANDLE); /* raise error condition */
743	}
744
745
746	/*****************************************************************************
747	* Name : DWORD HMHandleTranslateToOS2
748	* Purpose : translate a 16-bit Win32 handle to the associated OS/2 handle
749	* Parameters: ULONG hHandle16 - the windows handle
750	* PULONG phHandle32 - the associated OS/2 handle
751	* Variables :
752	* Result : API returncode
753	* Remark :
754	* Status :
755	*
756	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
757	*****************************************************************************/
758
759	DWORD HMHandleTranslateToOS2 (ULONG hHandle16,
760	PULONG phHandleOS2)
761	{
762	#ifdef DEBUG_LOCAL
763	dprintf(("KERNEL32: HMHandleTranslateToOS2 (%08xh, %08xh)\n",
764	hHandle16,
765	phHandleOS2));
766	#endif
767
768	if (HMHandleValidate(hHandle16) == NO_ERROR) /* verify handle */
769	{
770	*phHandleOS2 = TabWin32Handles[hHandle16].hmHandleData.hHMHandle;
771	return (NO_ERROR);
772	}
773
774	return (ERROR_INVALID_HANDLE); /* raise error condition */
775	}
776
777
778	/*****************************************************************************
779	* Name : DWORD HMHandleTranslateToOS2i
780	* Purpose : translate a 16-bit Win32 handle to the associated OS/2 handle
781	* Parameters: ULONG hHandle16 - the windows handle
782	* Variables :
783	* Result : OS/2 handle
784	* Remark : no checkinf
785	* Status :
786	*
787	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
788	*****************************************************************************/
789
790	DWORD HMHandleTranslateToOS2i (ULONG hHandle16)
791	{
792	#ifdef DEBUG_LOCAL
793	dprintf(("KERNEL32: HMHandleTranslateToOS2i (%08xh)\n",
794	hHandle16));
795	#endif
796
797	return(TabWin32Handles[hHandle16].hmHandleData.hHMHandle);
798	}
799
800	/*****************************************************************************
801	* Name : HANDLE _HMGetStdHandle
802	* Purpose : replacement for Open32's GetStdHandle function
803	* Parameters: DWORD nStdHandle
804	* Variables :
805	* Result : HANDLE to standard device
806	* Remark :
807	* Status :
808	*
809	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
810	*****************************************************************************/
811
812	HANDLE HMGetStdHandle(DWORD nStdHandle)
813	{
814	switch (nStdHandle)
815	{
816	case STD_INPUT_HANDLE: return (HMGlobals.hStandardIn);
817	case STD_OUTPUT_HANDLE: return (HMGlobals.hStandardOut);
818	case STD_ERROR_HANDLE: return (HMGlobals.hStandardError);
819
820	default:
821	{
822	SetLastError(ERROR_INVALID_PARAMETER); /* set error information */
823	return (INVALID_HANDLE_VALUE); /* raise error condition */
824	}
825	}
826	}
827
828
829	/*****************************************************************************
830	* Name : HANDLE _HMSetStdHandle
831	* Purpose : replacement for Open32's SetStdHandle function
832	* Parameters: DWORD nStdHandle
833	* HANDLE hHandle
834	* Variables :
835	* Result : BOOL fSuccess
836	* Remark :
837	* Status :
838	*
839	* Author : Patrick Haller [Wed, 1998/02/12 20:44]
840	*****************************************************************************/
841
842	BOOL HMSetStdHandle(DWORD nStdHandle, HANDLE hHandleOpen32)
843	{
844	PHMHANDLEDATA pHMHandleData;
845	HANDLE hHandle;
846
847	hHandle = _HMHandleGetFree(); /* get free handle */
848	if (hHandle == -1) /* oops, no free handles ! */
849	{
850	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
851	return 0;
852	}
853
854	/* initialize the complete HMHANDLEDATA structure */
855	pHMHandleData = &TabWin32Handles[hHandle].hmHandleData;
856	pHMHandleData->dwAccess = 0;
857	pHMHandleData->dwShare = 0;
858	pHMHandleData->dwCreation = 0;
859	pHMHandleData->dwFlags = 0;
860	pHMHandleData->dwUserData = nStdHandle;
861	pHMHandleData->hHMHandle = hHandleOpen32;
862	pHMHandleData->lpHandlerData = NULL;
863
864	TabWin32Handles[hHandle].pDeviceHandler = HMGlobals.pHMStandard;
865
866	switch (nStdHandle)
867	{
868	case STD_INPUT_HANDLE: HMGlobals.hStandardIn = hHandle; return TRUE;
869	case STD_OUTPUT_HANDLE: HMGlobals.hStandardOut = hHandle; return TRUE;
870	case STD_ERROR_HANDLE: HMGlobals.hStandardError = hHandle; return TRUE;
871
872	default:
873	{
874	SetLastError(ERROR_INVALID_PARAMETER); /* set error information */
875	return (FALSE); /* raise error condition */
876	}
877	}
878	}
879
880
881	/*****************************************************************************
882	* Name : HANDLE HMDuplicateHandle
883	* Purpose : replacement for Open32's HMDuplicateHandle function
884	* Parameters:
885	*
886	* Variables :
887	* Result : BOOL fSuccess
888	* Remark :
889	* Status :
890	*
891	* Author : Sander van Leeuwen [Wed, 1999/08/25 15:44]
892	*****************************************************************************/
893
894	BOOL HMDuplicateHandle(HANDLE srcprocess,
895	HANDLE srchandle,
896	HANDLE destprocess,
897	PHANDLE desthandle,
898	DWORD fdwAccess,
899	BOOL fInherit,
900	DWORD fdwOptions,
901	DWORD fdwOdinOptions)
902	{
903	int iIndex; /* index into the handle table */
904	int iIndexNew; /* index into the handle table */
905	HMDeviceHandler pDeviceHandler; / device handler for this handle */
906	PHMHANDLEDATA pHMHandleData;
907	BOOL rc; /* API return code */
908
909	if(HMHandleValidate(srchandle) != NO_ERROR)
910	{
911	dprintf(("KERNEL32: HMDuplicateHandle: invalid handle %x", srchandle));
912	SetLastError(ERROR_INVALID_HANDLE); /* use this as error message */
913	return FALSE;
914	}
915
916	pDeviceHandler = TabWin32Handles[srchandle].pDeviceHandler; /* device is predefined */
917	iIndexNew = _HMHandleGetFree(); /* get free handle */
918	if (-1 == iIndexNew) /* oops, no free handles ! */
919	{
920	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
921	return FALSE; /* signal error */
922	}
923
924	/* initialize the complete HMHANDLEDATA structure */
925	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
926	if (fdwOptions & DUPLICATE_SAME_ACCESS)
927	pHMHandleData->dwAccess = TabWin32Handles[srchandle].hmHandleData.dwAccess;
928	else
929	pHMHandleData->dwAccess = fdwAccess;
930
931	if((fdwOdinOptions & DUPLICATE_ACCESS_READWRITE) == DUPLICATE_ACCESS_READWRITE) {
932	pHMHandleData->dwAccess = GENERIC_READ \| GENERIC_WRITE;
933	}
934	else
935	if(fdwOdinOptions & DUPLICATE_ACCESS_READ) {
936	pHMHandleData->dwAccess = GENERIC_READ;
937	}
938
939	if(fdwOdinOptions & DUPLICATE_SHARE_READ) {
940	pHMHandleData->dwShare = FILE_SHARE_READ;
941	}
942	else
943	if(fdwOdinOptions & DUPLICATE_SHARE_DENYNONE) {
944	pHMHandleData->dwShare = FILE_SHARE_READ \| FILE_SHARE_WRITE;
945	}
946	else pHMHandleData->dwShare = TabWin32Handles[srchandle].hmHandleData.dwShare;
947
948	pHMHandleData->dwCreation = TabWin32Handles[srchandle].hmHandleData.dwCreation;
949	pHMHandleData->dwFlags = TabWin32Handles[srchandle].hmHandleData.dwFlags;
950	pHMHandleData->lpHandlerData = TabWin32Handles[srchandle].hmHandleData.lpHandlerData;
951
952
953	/* we've got to mark the handle as occupied here, since another device */
954	/* could be created within the device handler -> deadlock */
955
956	/* write appropriate entry into the handle table if open succeeded */
957	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
958	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
959	/* call the device handler */
960	rc = pDeviceHandler->DuplicateHandle(&TabWin32Handles[iIndexNew].hmHandleData,
961	srcprocess,
962	&TabWin32Handles[srchandle].hmHandleData,
963	destprocess,
964	desthandle,
965	fdwAccess,
966	fInherit,
967	fdwOptions & ~DUPLICATE_CLOSE_SOURCE,
968	fdwOdinOptions);
969
970	//Don't let Open32 close it for us, but do it manually (regardless of error; see SDK docs))
971	if (fdwOptions & DUPLICATE_CLOSE_SOURCE)
972	HMCloseHandle(srchandle);
973
974	if(rc == FALSE) /* oops, creation failed within the device handler */
975	{
976	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
977	return FALSE; /* signal error */
978	}
979	else
980	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
981
982	*desthandle = iIndexNew;
983	return TRUE; /* return valid handle */
984	}
985
986	/*****************************************************************************
987	* Name : HANDLE HMCreateFile
988	* Purpose : Wrapper for the CreateFile() API
989	* Parameters:
990	* Variables :
991	* Result :
992	* Remark : Fix parameters passed to the HMDeviceManager::CreateFile
993	* Supply access mode and share mode validation routines
994	* Status :
995	*
996	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
997	*****************************************************************************/
998
999	HFILE HMCreateFile(LPCSTR lpFileName,
1000	DWORD dwDesiredAccess,
1001	DWORD dwShareMode,
1002	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
1003	DWORD dwCreationDisposition,
1004	DWORD dwFlagsAndAttributes,
1005	HANDLE hTemplateFile)
1006	{
1007	int iIndex; /* index into the handle table */
1008	int iIndexNew; /* index into the handle table */
1009	HMDeviceHandler pDeviceHandler; / device handler for this handle */
1010	HANDLE hResult;
1011	DWORD rc; /* API return code */
1012	PHMHANDLEDATA pHMHandleData;
1013	HMHANDLEDATA HMHandleTemp; /* temporary buffer for handle data */
1014	VOID *pDevData;
1015
1016	/* create new handle by either lpFileName or hTemplateFile */
1017	if (lpFileName == NULL) /* this indicates creation from template */
1018	{
1019	iIndex = _HMHandleQuery(hTemplateFile); /* query table for template */
1020	if (-1 == iIndex) /* this device is unknown to us */
1021	{
1022	SetLastError (ERROR_INVALID_HANDLE);
1023	return INVALID_HANDLE_VALUE;
1024	}
1025	else
1026	{
1027	/* to pass to handler */
1028	pHMHandleData = &TabWin32Handles[iIndex].hmHandleData;
1029	pDeviceHandler = TabWin32Handles[iIndex].pDeviceHandler;
1030	}
1031	}
1032	else
1033	{
1034	// name resolving
1035	CHAR szFilename[260];
1036	if (TRUE == HandleNamesResolveName((PSZ)lpFileName,
1037	szFilename,
1038	sizeof(szFilename),
1039	TRUE))
1040	{
1041	// use the resolved name
1042	lpFileName = szFilename;
1043	}
1044
1045
1046	pDeviceHandler = _HMDeviceFind((LPSTR)lpFileName); /* find device */
1047	if (NULL == pDeviceHandler) /* this name is unknown to us */
1048	{
1049	SetLastError(ERROR_FILE_NOT_FOUND);
1050	return (INVALID_HANDLE_VALUE); /* signal error */
1051	}
1052	else
1053	pHMHandleData = NULL;
1054
1055	pDevData = _HMDeviceGetData((LPSTR)lpFileName);
1056
1057	if(pDeviceHandler == HMGlobals.pHMOpen32) {
1058	pDeviceHandler = HMGlobals.pHMFile;
1059	}
1060	}
1061
1062
1063	iIndexNew = _HMHandleGetFree(); /* get free handle */
1064	if (-1 == iIndexNew) /* oops, no free handles ! */
1065	{
1066	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
1067	return (INVALID_HANDLE_VALUE); /* signal error */
1068	}
1069
1070
1071	/* initialize the complete HMHANDLEDATA structure */
1072	if (lpFileName == NULL) /* create from template */
1073	memcpy (&HMHandleTemp,
1074	&TabWin32Handles[iIndex].hmHandleData,
1075	sizeof(HMHANDLEDATA));
1076	else
1077	{
1078	HMHandleTemp.dwAccess = dwDesiredAccess;
1079	HMHandleTemp.dwShare = dwShareMode;
1080	HMHandleTemp.dwCreation = dwCreationDisposition;
1081	HMHandleTemp.dwFlags = dwFlagsAndAttributes;
1082	HMHandleTemp.lpHandlerData = NULL;
1083	HMHandleTemp.hWin32Handle = iIndexNew;
1084	HMHandleTemp.lpDeviceData = pDevData;
1085	}
1086
1087	/* we've got to mark the handle as occupied here, since another device */
1088	/* could be created within the device handler -> deadlock */
1089
1090	/* write appropriate entry into the handle table if open succeeded */
1091	HMHandleTemp.hHMHandle = iIndexNew;
1092	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
1093	/* now copy back our temporary handle data */
1094	memcpy(&TabWin32Handles[iIndexNew].hmHandleData,
1095	&HMHandleTemp,
1096	sizeof(HMHANDLEDATA));
1097
1098	rc = pDeviceHandler->CreateFile(lpFileName, /* call the device handler */
1099	&HMHandleTemp,
1100	lpSecurityAttributes,
1101	pHMHandleData);
1102
1103	#ifdef DEBUG_LOCAL
1104	dprintf(("KERNEL32/HandleManager:CheckPoint2: %s lpHandlerData=%08xh\n",
1105	lpFileName,
1106	HMHandleTemp.lpHandlerData));
1107	#endif
1108
1109	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
1110	{
1111	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1112
1113	// Note:
1114	// device handlers have to return an Win32-style error code
1115	// from CreateFile() !
1116	SetLastError(rc);
1117	return (INVALID_HANDLE_VALUE); /* signal error */
1118	}
1119	else
1120	{
1121	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
1122
1123	/* copy data fields that might have been modified by CreateFile */
1124	memcpy(&TabWin32Handles[iIndexNew].hmHandleData,
1125	&HMHandleTemp,
1126	sizeof(HMHANDLEDATA));
1127	}
1128
1129	return (HFILE)iIndexNew; /* return valid handle */
1130	}
1131
1132
1133	/*****************************************************************************
1134	* Name : HANDLE HMOpenFile
1135	* Purpose : Wrapper for the OpenFile() API
1136	* Parameters:
1137	* Variables :
1138	* Result :
1139	* Remark : Fix parameters passed to the HMDeviceManager::OpenFile
1140	* Supply access mode and share mode validation routines
1141	* Status :
1142	*
1143	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1144	*****************************************************************************/
1145
1146
1147	/***********************************************************************
1148	* FILE_ConvertOFMode
1149	*
1150	* Convert OF_* mode into flags for CreateFile.
1151	*/
1152	static void FILE_ConvertOFMode( INT mode, DWORD access, DWORD sharing )
1153	{
1154	switch(mode & 0x03)
1155	{
1156	case OF_READ: *access = GENERIC_READ; break;
1157	case OF_WRITE: *access = GENERIC_WRITE; break;
1158	case OF_READWRITE: *access = GENERIC_READ \| GENERIC_WRITE; break;
1159	default: *access = 0; break;
1160	}
1161	switch(mode & 0x70)
1162	{
1163	case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
1164	case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
1165	case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
1166	case OF_SHARE_DENY_NONE:
1167	case OF_SHARE_COMPAT:
1168	default: *sharing = FILE_SHARE_READ \| FILE_SHARE_WRITE; break;
1169	}
1170	}
1171
1172	HANDLE HMOpenFile(LPCSTR lpFileName,
1173	OFSTRUCT* pOFStruct,
1174	UINT fuMode)
1175	{
1176	int iIndex; /* index into the handle table */
1177	int iIndexNew; /* index into the handle table */
1178	HMDeviceHandler pDeviceHandler; / device handler for this handle */
1179	VOID *pDevData;
1180	PHMHANDLEDATA pHMHandleData;
1181	DWORD rc; /* API return code */
1182
1183	// name resolving
1184	CHAR szFilename[260];
1185	if (TRUE == HandleNamesResolveName((PSZ)lpFileName,
1186	szFilename,
1187	sizeof(szFilename),
1188	TRUE))
1189	{
1190	// use the resolved name
1191	lpFileName = szFilename;
1192	}
1193
1194
1195	if(fuMode & OF_REOPEN) {
1196	pDeviceHandler = _HMDeviceFind((LPSTR)pOFStruct->szPathName); /* find device */
1197	}
1198	else pDeviceHandler = _HMDeviceFind((LPSTR)lpFileName); /* find device */
1199	if (NULL == pDeviceHandler) /* this name is unknown to us */
1200	{
1201	SetLastError(ERROR_FILE_NOT_FOUND);
1202	return (INVALID_HANDLE_VALUE); /* signal error */
1203	}
1204	else
1205	pHMHandleData = NULL;
1206
1207	if(fuMode & OF_REOPEN) {
1208	pDevData = _HMDeviceGetData((LPSTR)pOFStruct->szPathName);
1209	}
1210	else pDevData = _HMDeviceGetData((LPSTR)lpFileName);
1211
1212
1213	if(pDeviceHandler == HMGlobals.pHMOpen32) {
1214	pDeviceHandler = HMGlobals.pHMFile;
1215	}
1216
1217	iIndexNew = _HMHandleGetFree(); /* get free handle */
1218	if (-1 == iIndexNew) /* oops, no free handles ! */
1219	{
1220	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
1221	return (INVALID_HANDLE_VALUE); /* signal error */
1222	}
1223
1224	/* initialize the complete HMHANDLEDATA structure */
1225	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
1226
1227	FILE_ConvertOFMode(fuMode, /* map OF_flags */
1228	&pHMHandleData->dwAccess,
1229	&pHMHandleData->dwShare);
1230
1231	//SvL; Must be OPEN_EXISTING because mmaps depend on it (to duplicate
1232	// the file handle when this handle is a parameter for CreateFileMappingA/W
1233	pHMHandleData->dwCreation = OPEN_EXISTING;
1234	pHMHandleData->dwFlags = 0;
1235	pHMHandleData->lpHandlerData = NULL;
1236	pHMHandleData->lpDeviceData = pDevData;
1237
1238	/* we've got to mark the handle as occupied here, since another device */
1239	/* could be created within the device handler -> deadlock */
1240
1241	/* write appropriate entry into the handle table if open succeeded */
1242	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
1243	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
1244
1245	rc = pDeviceHandler->OpenFile(lpFileName, /* call the device handler */
1246	&TabWin32Handles[iIndexNew].hmHandleData,
1247	pOFStruct,
1248	fuMode);
1249
1250	#ifdef DEBUG_LOCAL
1251	dprintf(("KERNEL32/HandleManager:CheckPoint3: %s lpHandlerData=%08xh rc=%08xh\n",
1252	lpFileName,
1253	&TabWin32Handles[iIndexNew].hmHandleData.lpHandlerData,
1254	rc));
1255	#endif
1256
1257	if(rc != NO_ERROR) /* oops, creation failed within the device handler */
1258	{
1259	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1260	SetLastError(pOFStruct->nErrCode);
1261	return (INVALID_HANDLE_VALUE); /* signal error */
1262	}
1263	else {
1264	if(fuMode & (OF_DELETE\|OF_EXIST)) {
1265	//file handle already closed
1266	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1267	return TRUE; //TODO: correct?
1268	}
1269	if(fuMode & OF_PARSE) {
1270	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1271	return 0;
1272	}
1273	if(fuMode & OF_VERIFY) {
1274	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
1275	return 1; //TODO: correct?
1276	}
1277	}
1278
1279	#ifdef DEBUG_LOCAL
1280	dprintf(("KERNEL32/HandleManager: OpenFile(%s)=%08xh\n",
1281	lpFileName,
1282	iIndexNew));
1283	#endif
1284
1285	return iIndexNew; /* return valid handle */
1286	}
1287
1288
1289
1290	/*****************************************************************************
1291	* Name : HANDLE HMCloseFile
1292	* Purpose : Wrapper for the CloseHandle() API
1293	* Parameters:
1294	* Variables :
1295	* Result :
1296	* Remark :
1297	* Status :
1298	*
1299	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1300	*****************************************************************************/
1301
1302	BOOL HMCloseHandle(HANDLE hObject)
1303	{
1304	int iIndex; /* index into the handle table */
1305	BOOL fResult; /* result from the device handler's CloseHandle() */
1306	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1307
1308	/* validate handle */
1309	iIndex = _HMHandleQuery(hObject); /* get the index */
1310	if (-1 == iIndex) /* error ? */
1311	{
1312	//@@@PH it may occur someone closes e.g. a semaphore handle
1313	// which is not registered through the HandleManager yet.
1314	// so we try to pass on to Open32 instead.
1315	dprintf(("KERNEL32: HandleManager:HMCloseHandle(%08xh) passed on to Open32.\n",
1316	hObject));
1317
1318	fResult = O32_CloseHandle(hObject);
1319	return (fResult);
1320
1321	//SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1322	//return (FALSE); /* signal failure */
1323	}
1324
1325	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1326	//SvL: Check if pDeviceHandler is set
1327	if (pHMHandle->pDeviceHandler)
1328	{
1329	fResult = pHMHandle->pDeviceHandler->CloseHandle(&pHMHandle->hmHandleData);
1330	}
1331	else
1332	{
1333	dprintf(("HMCloseHAndle(%08xh): pDeviceHandler not set", hObject));
1334	fResult = TRUE;
1335	}
1336
1337	if (fResult == TRUE) /* remove handle if close succeeded */
1338	{
1339	pHMHandle->hmHandleData.hHMHandle = INVALID_HANDLE_VALUE; /* mark handle as free */
1340	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
1341	}
1342
1343	return (fResult); /* deliver return code */
1344	}
1345
1346
1347	/*****************************************************************************
1348	* Name : HANDLE HMReadFile
1349	* Purpose : Wrapper for the ReadHandle() API
1350	* Parameters:
1351	* Variables :
1352	* Result :
1353	* Remark :
1354	* Status :
1355	*
1356	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1357	*****************************************************************************/
1358
1359	BOOL HMReadFile(HANDLE hFile,
1360	LPVOID lpBuffer,
1361	DWORD nNumberOfBytesToRead,
1362	LPDWORD lpNumberOfBytesRead,
1363	LPOVERLAPPED lpOverlapped,
1364	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1365	{
1366	int iIndex; /* index into the handle table */
1367	BOOL fResult; /* result from the device handler's CloseHandle() */
1368	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1369
1370	/* validate handle */
1371	iIndex = _HMHandleQuery(hFile); /* get the index */
1372	if (-1 == iIndex) /* error ? */
1373	{
1374	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1375	return (FALSE); /* signal failure */
1376	}
1377
1378	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1379	fResult = pHMHandle->pDeviceHandler->ReadFile(&pHMHandle->hmHandleData,
1380	lpBuffer,
1381	nNumberOfBytesToRead,
1382	lpNumberOfBytesRead,
1383	lpOverlapped, lpCompletionRoutine);
1384
1385	return (fResult); /* deliver return code */
1386	}
1387
1388	/*****************************************************************************
1389	* Name : HANDLE HMWriteFile
1390	* Purpose : Wrapper for the WriteHandle() API
1391	* Parameters:
1392	* Variables :
1393	* Result :
1394	* Remark :
1395	* Status :
1396	*
1397	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1398	*****************************************************************************/
1399
1400	BOOL HMWriteFile(HANDLE hFile,
1401	LPCVOID lpBuffer,
1402	DWORD nNumberOfBytesToWrite,
1403	LPDWORD lpNumberOfBytesWritten,
1404	LPOVERLAPPED lpOverlapped,
1405	LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
1406	{
1407	int iIndex; /* index into the handle table */
1408	BOOL fResult; /* result from the device handler's CloseHandle() */
1409	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1410
1411	/* validate handle */
1412	iIndex = _HMHandleQuery(hFile); /* get the index */
1413	if (-1 == iIndex) /* error ? */
1414	{
1415	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1416	return (FALSE); /* signal failure */
1417	}
1418
1419	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1420	fResult = pHMHandle->pDeviceHandler->WriteFile(&pHMHandle->hmHandleData,
1421	lpBuffer,
1422	nNumberOfBytesToWrite,
1423	lpNumberOfBytesWritten,
1424	lpOverlapped, lpCompletionRoutine);
1425
1426	return (fResult); /* deliver return code */
1427	}
1428
1429
1430	/*****************************************************************************
1431	* Name : HANDLE HMGetFileType
1432	* Purpose : Wrapper for the GetFileType() API
1433	* Parameters:
1434	* Variables :
1435	* Result :
1436	* Remark :
1437	* Status :
1438	*
1439	* Author : Patrick Haller [Wed, 1998/02/12 13:37]
1440	*****************************************************************************/
1441
1442	DWORD HMGetFileType(HANDLE hFile)
1443	{
1444	int iIndex; /* index into the handle table */
1445	DWORD dwResult; /* result from the device handler's API */
1446	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1447
1448	/* validate handle */
1449	iIndex = _HMHandleQuery(hFile); /* get the index */
1450	if (-1 == iIndex) /* error ? */
1451	{
1452	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1453	return FILE_TYPE_UNKNOWN; /* signal failure */
1454	}
1455
1456	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1457	dwResult = pHMHandle->pDeviceHandler->GetFileType(&pHMHandle->hmHandleData);
1458
1459	return (dwResult); /* deliver return code */
1460	}
1461
1462
1463	/*****************************************************************************
1464	* Name : HMDeviceHandler::_DeviceReuqest
1465	* Purpose : entry method for special request functions
1466	* Parameters: ULONG ulRequestCode
1467	* various parameters as required
1468	* Variables :
1469	* Result :
1470	* Remark : the standard behaviour is to return an error code for non-
1471	* existant request codes
1472	* Status :
1473	*
1474	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
1475	*****************************************************************************/
1476
1477	DWORD HMDeviceRequest (HANDLE hFile,
1478	ULONG ulRequestCode,
1479	ULONG arg1,
1480	ULONG arg2,
1481	ULONG arg3,
1482	ULONG arg4)
1483	{
1484	int iIndex; /* index into the handle table */
1485	DWORD dwResult; /* result from the device handler's API */
1486	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1487
1488	/* validate handle */
1489	iIndex = _HMHandleQuery(hFile); /* get the index */
1490	if (-1 == iIndex) /* error ? */
1491	{
1492	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1493	return (INVALID_HANDLE_ERROR); /* signal failure */
1494	}
1495
1496	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1497	dwResult = pHMHandle->pDeviceHandler->_DeviceRequest(&pHMHandle->hmHandleData,
1498	ulRequestCode,
1499	arg1,
1500	arg2,
1501	arg3,
1502	arg4);
1503
1504	return (dwResult); /* deliver return code */
1505	}
1506
1507
1508	/*****************************************************************************
1509	* Name : HMDeviceHandler::GetFileInformationByHandle
1510	* Purpose : router function for GetFileInformationByHandle
1511	* Parameters:
1512	* Variables :
1513	* Result :
1514	* Remark :
1515	* Status :
1516	*
1517	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1518	*****************************************************************************/
1519
1520	BOOL HMGetFileInformationByHandle (HANDLE hFile,
1521	BY_HANDLE_FILE_INFORMATION *pHFI)
1522	{
1523	int iIndex; /* index into the handle table */
1524	DWORD dwResult; /* result from the device handler's API */
1525	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1526
1527	/* validate handle */
1528	iIndex = _HMHandleQuery(hFile); /* get the index */
1529	if (-1 == iIndex) /* error ? */
1530	{
1531	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1532	return FALSE; /* signal failure */
1533	}
1534
1535	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1536	dwResult = pHMHandle->pDeviceHandler->GetFileInformationByHandle(&pHMHandle->hmHandleData,
1537	pHFI);
1538
1539	return (dwResult); /* deliver return code */
1540	}
1541
1542
1543	/*****************************************************************************
1544	* Name : HMDeviceHandler::SetEndOfFile
1545	* Purpose : router function for SetEndOfFile
1546	* Parameters:
1547	* Variables :
1548	* Result :
1549	* Remark :
1550	* Status :
1551	*
1552	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1553	*****************************************************************************/
1554
1555	BOOL HMSetEndOfFile (HANDLE hFile)
1556	{
1557	int iIndex; /* index into the handle table */
1558	BOOL bResult; /* result from the device handler's API */
1559	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1560
1561	/* validate handle */
1562	iIndex = _HMHandleQuery(hFile); /* get the index */
1563	if (-1 == iIndex) /* error ? */
1564	{
1565	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1566	return FALSE; /* signal failure */
1567	}
1568
1569	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1570	bResult = pHMHandle->pDeviceHandler->SetEndOfFile(&pHMHandle->hmHandleData);
1571
1572	return (bResult); /* deliver return code */
1573	}
1574
1575
1576	/*****************************************************************************
1577	* Name : HMDeviceHandler::SetFileTime
1578	* Purpose : router function for SetFileTime
1579	* Parameters:
1580	* Variables :
1581	* Result :
1582	* Remark :
1583	* Status :
1584	*
1585	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1586	*****************************************************************************/
1587
1588	BOOL HMSetFileTime (HANDLE hFile,
1589	const FILETIME *pFT1,
1590	const FILETIME *pFT2,
1591	const FILETIME *pFT3)
1592	{
1593	int iIndex; /* index into the handle table */
1594	BOOL bResult; /* result from the device handler's API */
1595	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1596
1597	/* validate handle */
1598	iIndex = _HMHandleQuery(hFile); /* get the index */
1599	if (-1 == iIndex) /* error ? */
1600	{
1601	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1602	return FALSE; /* signal failure */
1603	}
1604
1605	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1606	bResult = pHMHandle->pDeviceHandler->SetFileTime(&pHMHandle->hmHandleData,
1607	(LPFILETIME)pFT1,
1608	(LPFILETIME)pFT2,
1609	(LPFILETIME)pFT3);
1610
1611	return (bResult); /* deliver return code */
1612	}
1613
1614	/*****************************************************************************
1615	* Name : HMDeviceHandler::GetFileTime
1616	* Purpose : router function for SetFileTime
1617	* Parameters:
1618	* Variables :
1619	* Result :
1620	* Remark :
1621	* Status :
1622	*
1623	* Author : SvL
1624	*****************************************************************************/
1625
1626	BOOL HMGetFileTime (HANDLE hFile,
1627	const FILETIME *pFT1,
1628	const FILETIME *pFT2,
1629	const FILETIME *pFT3)
1630	{
1631	int iIndex; /* index into the handle table */
1632	BOOL bResult; /* result from the device handler's API */
1633	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1634
1635	/* validate handle */
1636	iIndex = _HMHandleQuery(hFile); /* get the index */
1637	if (-1 == iIndex) /* error ? */
1638	{
1639	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1640	return FALSE; /* signal failure */
1641	}
1642
1643	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1644	bResult = pHMHandle->pDeviceHandler->GetFileTime(&pHMHandle->hmHandleData,
1645	(LPFILETIME)pFT1,
1646	(LPFILETIME)pFT2,
1647	(LPFILETIME)pFT3);
1648
1649	return (bResult); /* deliver return code */
1650	}
1651
1652
1653	/*****************************************************************************
1654	* Name : HMDeviceHandler::GetFileSize
1655	* Purpose : router function for GetFileSize
1656	* Parameters:
1657	* Variables :
1658	* Result :
1659	* Remark :
1660	* Status :
1661	*
1662	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1663	*****************************************************************************/
1664
1665	DWORD HMGetFileSize (HANDLE hFile,
1666	PDWORD pSize)
1667	{
1668	int iIndex; /* index into the handle table */
1669	DWORD dwResult; /* result from the device handler's API */
1670	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1671
1672	/* validate handle */
1673	iIndex = _HMHandleQuery(hFile); /* get the index */
1674	if (-1 == iIndex) /* error ? */
1675	{
1676	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1677	return -1; //INVALID_SET_FILE_POINTER
1678	}
1679
1680	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1681	dwResult = pHMHandle->pDeviceHandler->GetFileSize(&pHMHandle->hmHandleData,
1682	pSize);
1683
1684	return (dwResult); /* deliver return code */
1685	}
1686
1687
1688	/*****************************************************************************
1689	* Name : HMDeviceHandler::SetFilePointer
1690	* Purpose : router function for SetFilePointer
1691	* Parameters:
1692	* Variables :
1693	* Result :
1694	* Remark :
1695	* Status :
1696	*
1697	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1698	*****************************************************************************/
1699
1700	DWORD HMSetFilePointer (HANDLE hFile,
1701	LONG lDistanceToMove,
1702	PLONG lpDistanceToMoveHigh,
1703	DWORD dwMoveMethod)
1704	{
1705	int iIndex; /* index into the handle table */
1706	DWORD dwResult; /* result from the device handler's API */
1707	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1708
1709	/* validate handle */
1710	iIndex = _HMHandleQuery(hFile); /* get the index */
1711	if (-1 == iIndex) /* error ? */
1712	{
1713	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1714	return (INVALID_HANDLE_ERROR); /* signal failure */
1715	}
1716
1717	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1718	dwResult = pHMHandle->pDeviceHandler->SetFilePointer(&pHMHandle->hmHandleData,
1719	lDistanceToMove,
1720	lpDistanceToMoveHigh,
1721	dwMoveMethod);
1722
1723	return (dwResult); /* deliver return code */
1724	}
1725
1726
1727	/*****************************************************************************
1728	* Name : HMDeviceHandler::LockFile
1729	* Purpose : router function for LockFile
1730	* Parameters:
1731	* Variables :
1732	* Result :
1733	* Remark :
1734	* Status :
1735	*
1736	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1737	*****************************************************************************/
1738
1739	BOOL HMLockFile (HFILE hFile,
1740	DWORD arg2,
1741	DWORD arg3,
1742	DWORD arg4,
1743	DWORD arg5)
1744	{
1745	int iIndex; /* index into the handle table */
1746	DWORD dwResult; /* result from the device handler's API */
1747	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1748
1749	/* validate handle */
1750	iIndex = _HMHandleQuery(hFile); /* get the index */
1751	if (-1 == iIndex) /* error ? */
1752	{
1753	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1754	return FALSE; /* signal failure */
1755	}
1756
1757	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1758	dwResult = pHMHandle->pDeviceHandler->LockFile(&pHMHandle->hmHandleData,
1759	arg2,
1760	arg3,
1761	arg4,
1762	arg5);
1763
1764	return (dwResult); /* deliver return code */
1765	}
1766
1767
1768	/*****************************************************************************
1769	* Name : HMDeviceHandler::LockFileEx
1770	* Purpose : router function for LockFileEx
1771	* Parameters:
1772	* Variables :
1773	* Result :
1774	* Remark :
1775	* Status :
1776	*
1777	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1778	*****************************************************************************/
1779
1780	BOOL HMLockFileEx(HANDLE hFile,
1781	DWORD dwFlags,
1782	DWORD dwReserved,
1783	DWORD nNumberOfBytesToLockLow,
1784	DWORD nNumberOfBytesToLockHigh,
1785	LPOVERLAPPED lpOverlapped)
1786	{
1787	int iIndex; /* index into the handle table */
1788	DWORD dwResult; /* result from the device handler's API */
1789	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1790
1791	/* validate handle */
1792	iIndex = _HMHandleQuery(hFile); /* get the index */
1793	if (-1 == iIndex) /* error ? */
1794	{
1795	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1796	return FALSE; /* signal failure */
1797	}
1798
1799	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1800	dwResult = pHMHandle->pDeviceHandler->LockFileEx(&pHMHandle->hmHandleData,
1801	dwFlags,
1802	dwReserved,
1803	nNumberOfBytesToLockLow,
1804	nNumberOfBytesToLockHigh,
1805	lpOverlapped);
1806
1807	return (dwResult); /* deliver return code */
1808	}
1809
1810
1811
1812	/*****************************************************************************
1813	* Name : HMDeviceHandler::UnlockFile
1814	* Purpose : router function for UnlockFile
1815	* Parameters:
1816	* Variables :
1817	* Result :
1818	* Remark :
1819	* Status :
1820	*
1821	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1822	*****************************************************************************/
1823
1824	BOOL HMUnlockFile (HFILE hFile,
1825	DWORD arg2,
1826	DWORD arg3,
1827	DWORD arg4,
1828	DWORD arg5)
1829	{
1830	int iIndex; /* index into the handle table */
1831	DWORD dwResult; /* result from the device handler's API */
1832	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1833
1834	/* validate handle */
1835	iIndex = _HMHandleQuery(hFile); /* get the index */
1836	if (-1 == iIndex) /* error ? */
1837	{
1838	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1839	return FALSE; /* signal failure */
1840	}
1841
1842	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1843	dwResult = pHMHandle->pDeviceHandler->UnlockFile(&pHMHandle->hmHandleData,
1844	arg2,
1845	arg3,
1846	arg4,
1847	arg5);
1848
1849	return (dwResult); /* deliver return code */
1850	}
1851
1852
1853	/*****************************************************************************
1854	* Name : HMDeviceHandler::UnlockFileEx
1855	* Purpose : router function for UnlockFileEx
1856	* Parameters:
1857	* Variables :
1858	* Result :
1859	* Remark :
1860	* Status :
1861	*
1862	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1863	*****************************************************************************/
1864
1865	BOOL HMUnlockFileEx(HANDLE hFile,
1866	DWORD dwReserved,
1867	DWORD nNumberOfBytesToLockLow,
1868	DWORD nNumberOfBytesToLockHigh,
1869	LPOVERLAPPED lpOverlapped)
1870	{
1871	int iIndex; /* index into the handle table */
1872	DWORD dwResult; /* result from the device handler's API */
1873	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1874
1875	/* validate handle */
1876	iIndex = _HMHandleQuery(hFile); /* get the index */
1877	if (-1 == iIndex) /* error ? */
1878	{
1879	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
1880	return FALSE; /* signal failure */
1881	}
1882
1883	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1884	dwResult = pHMHandle->pDeviceHandler->UnlockFileEx(&pHMHandle->hmHandleData,
1885	dwReserved,
1886	nNumberOfBytesToLockLow,
1887	nNumberOfBytesToLockHigh,
1888	lpOverlapped);
1889
1890	return (dwResult); /* deliver return code */
1891	}
1892
1893
1894	/*****************************************************************************
1895	* Name : HMDeviceHandler::WaitForSingleObject
1896	* Purpose : router function for WaitForSingleObject
1897	* Parameters:
1898	* Variables :
1899	* Result :
1900	* Remark :
1901	* Status :
1902	*
1903	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
1904	*****************************************************************************/
1905
1906	DWORD HMWaitForSingleObject(HANDLE hObject,
1907	DWORD dwTimeout)
1908	{
1909	int iIndex; /* index into the handle table */
1910	DWORD dwResult; /* result from the device handler's API */
1911	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
1912
1913	/* validate handle */
1914	iIndex = _HMHandleQuery(hObject); /* get the index */
1915	if (-1 == iIndex) /* error ? */
1916	{
1917	dprintf(("KERNEL32: HandleManager:HMWaitForSingleObject(%08xh) passed on to Open32.\n",
1918	hObject));
1919
1920	if(dwTimeout == INFINITE) {
1921	//Workaround for applications that block the PM input queue
1922	//while waiting for a child process to terminate.
1923	//(WaitSingleObject now calls MsgWaitMultipleObjects and
1924	// processes messages while waiting for the process to die)
1925	//(Napster install now doesn't block PM anymore (forcing a reboot))
1926
1927	HMODULE hUser32 = LoadLibraryA("USER32.DLL");
1928
1929	BOOL (* WINAPI pfnPeekMessageA)(LPMSG,HWND,UINT,UINT,UINT);
1930	LONG (* WINAPI pfnDispatchMessageA)(const MSG*);
1931
1932	(FARPROC )&pfnPeekMessageA = GetProcAddress(hUser32,"PeekMessageA");
1933	(FARPROC )&pfnDispatchMessageA = GetProcAddress(hUser32,"DispatchMessageA");
1934
1935	TEB *teb = GetThreadTEB();
1936
1937	if(!teb \|\| !pfnPeekMessageA \|\| !pfnDispatchMessageA) {
1938	dprintf(("ERROR: !teb \|\| !pfnPeekMessageA \|\| !pfnDispatchMessageA"));
1939	DebugInt3();
1940	return WAIT_FAILED;
1941	}
1942
1943	//TODO: Ignoring all messages could be dangerous. But processing them,
1944	//while the app doesn't expect any, isn't safe either.
1945	//-> must active check in pmwindow.cpp if this is enabled again!
1946	// teb->o.odin.fIgnoreMsgs = TRUE;
1947
1948	while(TRUE) {
1949	dwResult = HMMsgWaitForMultipleObjects(1, &hObject, FALSE,
1950	INFINITE, QS_ALLINPUT);
1951	if(dwResult == WAIT_OBJECT_0 + 1) {
1952	MSG msg ;
1953
1954	while (pfnPeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1955	{
1956	if (msg.message == WM_QUIT) {
1957	dprintf(("ERROR: WaitForSingleObject call abandoned because WM_QUIT msg was received!!"));
1958	// teb->o.odin.fIgnoreMsgs = FALSE;
1959	FreeLibrary(hUser32);
1960	return WAIT_ABANDONED;
1961	}
1962
1963	/* otherwise dispatch it */
1964	pfnDispatchMessageA(&msg);
1965
1966	} // end of PeekMessage while loop
1967	}
1968	else {
1969	dprintf(("WaitForSingleObject: Process %x terminated", hObject));
1970	break;
1971	}
1972	}
1973	// teb->o.odin.fIgnoreMsgs = FALSE;
1974	FreeLibrary(hUser32);
1975	return dwResult;
1976	}
1977	else {
1978	// maybe handles from CreateProcess() ...
1979	dwResult = O32_WaitForSingleObject(hObject, dwTimeout);
1980	return (dwResult);
1981	}
1982	}
1983
1984	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
1985	dwResult = pHMHandle->pDeviceHandler->WaitForSingleObject(&pHMHandle->hmHandleData,
1986	dwTimeout);
1987
1988	return (dwResult); /* deliver return code */
1989	}
1990
1991
1992	/*****************************************************************************
1993	* Name : HMDeviceHandler::WaitForSingleObjectEx
1994	* Purpose : router function for WaitForSingleObjectEx
1995	* Parameters:
1996	* Variables :
1997	* Result :
1998	* Remark :
1999	* Status :
2000	*
2001	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2002	*****************************************************************************/
2003
2004	DWORD HMWaitForSingleObjectEx(HANDLE hObject,
2005	DWORD dwTimeout,
2006	BOOL fAlertable)
2007	{
2008	int iIndex; /* index into the handle table */
2009	DWORD dwResult; /* result from the device handler's API */
2010	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2011
2012	/* validate handle */
2013	iIndex = _HMHandleQuery(hObject); /* get the index */
2014	if (-1 == iIndex) /* error ? */
2015	{
2016	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2017	return WAIT_FAILED; /* signal failure */
2018	}
2019
2020	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2021	dwResult = pHMHandle->pDeviceHandler->WaitForSingleObjectEx(&pHMHandle->hmHandleData,
2022	dwTimeout,
2023	fAlertable);
2024
2025	return (dwResult); /* deliver return code */
2026	}
2027
2028
2029	/*****************************************************************************
2030	* Name : HMDeviceHandler::FlushFileBuffers
2031	* Purpose : router function for FlushFileBuffers
2032	* Parameters:
2033	* Variables :
2034	* Result :
2035	* Remark :
2036	* Status :
2037	*
2038	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2039	*****************************************************************************/
2040
2041	BOOL HMFlushFileBuffers(HANDLE hFile)
2042	{
2043	int iIndex; /* index into the handle table */
2044	DWORD dwResult; /* result from the device handler's API */
2045	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2046
2047	/* validate handle */
2048	iIndex = _HMHandleQuery(hFile); /* get the index */
2049	if (-1 == iIndex) /* error ? */
2050	{
2051	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2052	return FALSE; /* signal failure */
2053	}
2054
2055	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2056	dwResult = pHMHandle->pDeviceHandler->FlushFileBuffers(&pHMHandle->hmHandleData);
2057
2058	return (dwResult); /* deliver return code */
2059	}
2060
2061
2062	/*****************************************************************************
2063	* Name : HMDeviceHandler::GetOverlappedResult
2064	* Purpose : router function for GetOverlappedResult
2065	* Parameters:
2066	* Variables :
2067	* Result :
2068	* Remark :
2069	* Status :
2070	*
2071	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2072	*****************************************************************************/
2073
2074	BOOL HMGetOverlappedResult(HANDLE hObject,
2075	LPOVERLAPPED lpOverlapped,
2076	LPDWORD arg3,
2077	BOOL arg4)
2078	{
2079	int iIndex; /* index into the handle table */
2080	DWORD dwResult; /* result from the device handler's API */
2081	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2082
2083	/* validate handle */
2084	iIndex = _HMHandleQuery(hObject); /* get the index */
2085	if (-1 == iIndex) /* error ? */
2086	{
2087	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2088	return FALSE; /* signal failure */
2089	}
2090
2091	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2092	dwResult = pHMHandle->pDeviceHandler->GetOverlappedResult(&pHMHandle->hmHandleData,
2093	lpOverlapped,
2094	arg3,
2095	arg4);
2096
2097	return (dwResult); /* deliver return code */
2098	}
2099
2100
2101	/*****************************************************************************
2102	* Name : HMReleaseMutex
2103	* Purpose : router function for ReleaseMutex
2104	* Parameters:
2105	* Variables :
2106	* Result :
2107	* Remark :
2108	* Status :
2109	*
2110	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2111	*****************************************************************************/
2112
2113	BOOL HMReleaseMutex(HANDLE hObject)
2114	{
2115	int iIndex; /* index into the handle table */
2116	DWORD dwResult; /* result from the device handler's API */
2117	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2118
2119	/* validate handle */
2120	iIndex = _HMHandleQuery(hObject); /* get the index */
2121	if (-1 == iIndex) /* error ? */
2122	{
2123	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2124	return FALSE; /* signal failure */
2125	}
2126
2127	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2128	dwResult = pHMHandle->pDeviceHandler->ReleaseMutex(&pHMHandle->hmHandleData);
2129
2130	return (dwResult); /* deliver return code */
2131	}
2132
2133
2134	/*****************************************************************************
2135	* Name : HMSetEvent
2136	* Purpose : router function for SetEvent
2137	* Parameters:
2138	* Variables :
2139	* Result :
2140	* Remark :
2141	* Status :
2142	*
2143	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2144	*****************************************************************************/
2145
2146	BOOL HMSetEvent(HANDLE hEvent)
2147	{
2148	int iIndex; /* index into the handle table */
2149	DWORD dwResult; /* result from the device handler's API */
2150	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2151
2152	/* validate handle */
2153	iIndex = _HMHandleQuery(hEvent); /* get the index */
2154	if (-1 == iIndex) /* error ? */
2155	{
2156	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2157	return FALSE; /* signal failure */
2158	}
2159
2160	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2161	dwResult = pHMHandle->pDeviceHandler->SetEvent(&pHMHandle->hmHandleData);
2162
2163	return (dwResult); /* deliver return code */
2164	}
2165
2166
2167	/*****************************************************************************
2168	* Name : HMPulseEvent
2169	* Purpose : router function for PulseEvent
2170	* Parameters:
2171	* Variables :
2172	* Result :
2173	* Remark :
2174	* Status :
2175	*
2176	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2177	*****************************************************************************/
2178
2179	BOOL HMPulseEvent(HANDLE hEvent)
2180	{
2181	int iIndex; /* index into the handle table */
2182	DWORD dwResult; /* result from the device handler's API */
2183	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2184
2185	/* validate handle */
2186	iIndex = _HMHandleQuery(hEvent); /* get the index */
2187	if (-1 == iIndex) /* error ? */
2188	{
2189	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2190	return FALSE; /* signal failure */
2191	}
2192
2193	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2194	dwResult = pHMHandle->pDeviceHandler->PulseEvent(&pHMHandle->hmHandleData);
2195
2196	return (dwResult); /* deliver return code */
2197	}
2198
2199
2200	/*****************************************************************************
2201	* Name : HMResetEvent
2202	* Purpose : router function for ResetEvent
2203	* Parameters:
2204	* Variables :
2205	* Result :
2206	* Remark :
2207	* Status :
2208	*
2209	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2210	*****************************************************************************/
2211
2212	BOOL HMResetEvent(HANDLE hEvent)
2213	{
2214	int iIndex; /* index into the handle table */
2215	DWORD dwResult; /* result from the device handler's API */
2216	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2217
2218	/* validate handle */
2219	iIndex = _HMHandleQuery(hEvent); /* get the index */
2220	if (-1 == iIndex) /* error ? */
2221	{
2222	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2223	return FALSE; /* signal failure */
2224	}
2225
2226	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2227	dwResult = pHMHandle->pDeviceHandler->ResetEvent(&pHMHandle->hmHandleData);
2228
2229	return (dwResult); /* deliver return code */
2230	}
2231
2232
2233	/*****************************************************************************
2234	* Name : HANDLE HMCreateEvent
2235	* Purpose : Wrapper for the CreateEvent() API
2236	* Parameters:
2237	* Variables :
2238	* Result :
2239	* Remark :
2240	* Status :
2241	*
2242	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2243	*****************************************************************************/
2244
2245	HANDLE HMCreateEvent(LPSECURITY_ATTRIBUTES lpsa,
2246	BOOL bManualReset,
2247	BOOL bInitialState,
2248	LPCTSTR lpName)
2249	{
2250	int iIndex; /* index into the handle table */
2251	int iIndexNew; /* index into the handle table */
2252	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2253	PHMHANDLEDATA pHMHandleData;
2254	DWORD rc; /* API return code */
2255
2256
2257	if(lpName) { //check if shared event semaphore already exists
2258	//TODO: No inheritance??
2259	HANDLE handle = HMOpenEvent(EVENT_ALL_ACCESS, FALSE, lpName);
2260	if(handle) {
2261	dprintf(("CreateEvent: return handle of existing event semaphore %x", handle));
2262	SetLastError(ERROR_ALREADY_EXISTS);
2263	return handle;
2264	}
2265	}
2266
2267	pDeviceHandler = HMGlobals.pHMEvent; /* device is predefined */
2268
2269	iIndexNew = _HMHandleGetFree(); /* get free handle */
2270	if (-1 == iIndexNew) /* oops, no free handles ! */
2271	{
2272	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2273	return 0; /* signal error */
2274	}
2275
2276	/* Initialize the complete HMHANDLEDATA structure */
2277	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2278	pHMHandleData->dwAccess = 0;
2279	pHMHandleData->dwShare = 0;
2280	pHMHandleData->dwCreation = 0;
2281	pHMHandleData->dwFlags = 0;
2282	pHMHandleData->lpHandlerData = NULL;
2283
2284	/* we've got to mark the handle as occupied here, since another device */
2285	/* could be created within the device handler -> deadlock */
2286
2287	/* write appropriate entry into the handle table if open succeeded */
2288	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2289	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2290
2291	/* call the device handler */
2292	rc = pDeviceHandler->CreateEvent(&TabWin32Handles[iIndexNew].hmHandleData,
2293	lpsa,
2294	bManualReset,
2295	bInitialState,
2296	lpName);
2297	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2298	{
2299	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2300	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2301	return 0; /* signal error */
2302	}
2303	else
2304	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2305
2306	return iIndexNew; /* return valid handle */
2307	}
2308
2309
2310	/*****************************************************************************
2311	* Name : HANDLE HMCreateMutex
2312	* Purpose : Wrapper for the CreateMutex() API
2313	* Parameters:
2314	* Variables :
2315	* Result :
2316	* Remark :
2317	* Status :
2318	*
2319	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2320	*****************************************************************************/
2321
2322	HANDLE HMCreateMutex(LPSECURITY_ATTRIBUTES lpsa,
2323	BOOL bInitialOwner,
2324	LPCTSTR lpName)
2325	{
2326	int iIndex; /* index into the handle table */
2327	int iIndexNew; /* index into the handle table */
2328	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2329	PHMHANDLEDATA pHMHandleData;
2330	DWORD rc; /* API return code */
2331
2332
2333	if(lpName) { //check if shared mutex semaphore already exists
2334	//TODO: No inheritance??
2335	HANDLE handle = HMOpenMutex(MUTEX_ALL_ACCESS, FALSE, lpName);
2336	if(handle) {
2337	dprintf(("CreateMutex: return handle of existing mutex semaphore %x", handle));
2338	SetLastError(ERROR_ALREADY_EXISTS);
2339	return handle;
2340	}
2341	}
2342
2343	pDeviceHandler = HMGlobals.pHMMutex; /* device is predefined */
2344
2345	iIndexNew = _HMHandleGetFree(); /* get free handle */
2346	if (-1 == iIndexNew) /* oops, no free handles ! */
2347	{
2348	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2349	return 0; /* signal error */
2350	}
2351
2352
2353	/* initialize the complete HMHANDLEDATA structure */
2354	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2355	pHMHandleData->dwAccess = 0;
2356	pHMHandleData->dwShare = 0;
2357	pHMHandleData->dwCreation = 0;
2358	pHMHandleData->dwFlags = 0;
2359	pHMHandleData->lpHandlerData = NULL;
2360
2361
2362	/* we've got to mark the handle as occupied here, since another device */
2363	/* could be created within the device handler -> deadlock */
2364
2365	/* write appropriate entry into the handle table if open succeeded */
2366	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2367	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2368
2369	/* call the device handler */
2370	rc = pDeviceHandler->CreateMutex(&TabWin32Handles[iIndexNew].hmHandleData,
2371	lpsa,
2372	bInitialOwner,
2373	lpName);
2374	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2375	{
2376	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2377	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2378	return 0; /* signal error */
2379	}
2380	else
2381	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2382
2383	return iIndexNew; /* return valid handle */
2384	}
2385
2386
2387	/*****************************************************************************
2388	* Name : HANDLE HMOpenEvent
2389	* Purpose : Wrapper for the OpenEvent() API
2390	* Parameters:
2391	* Variables :
2392	* Result :
2393	* Remark :
2394	* Status :
2395	*
2396	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2397	*****************************************************************************/
2398
2399	HANDLE HMOpenEvent(DWORD fdwAccess,
2400	BOOL fInherit,
2401	LPCTSTR lpName)
2402	{
2403	int iIndex; /* index into the handle table */
2404	int iIndexNew; /* index into the handle table */
2405	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2406	PHMHANDLEDATA pHMHandleData;
2407	DWORD rc; /* API return code */
2408
2409
2410	pDeviceHandler = HMGlobals.pHMEvent; /* device is predefined */
2411
2412	iIndexNew = _HMHandleGetFree(); /* get free handle */
2413	if (-1 == iIndexNew) /* oops, no free handles ! */
2414	{
2415	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2416	return 0; /* signal error */
2417	}
2418
2419
2420	/* initialize the complete HMHANDLEDATA structure */
2421	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2422	pHMHandleData->dwAccess = fdwAccess;
2423	pHMHandleData->dwShare = 0;
2424	pHMHandleData->dwCreation = 0;
2425	pHMHandleData->dwFlags = 0;
2426	pHMHandleData->lpHandlerData = NULL;
2427
2428
2429	/* we've got to mark the handle as occupied here, since another device */
2430	/* could be created within the device handler -> deadlock */
2431
2432	/* write appropriate entry into the handle table if open succeeded */
2433	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2434	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2435
2436	/* call the device handler */
2437	rc = pDeviceHandler->OpenEvent(&TabWin32Handles[iIndexNew].hmHandleData,
2438	fInherit,
2439	lpName);
2440	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2441	{
2442	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2443	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2444	return 0; /* signal error */
2445	}
2446	else
2447	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2448
2449	return iIndexNew; /* return valid handle */
2450	}
2451
2452
2453	/*****************************************************************************
2454	* Name : HANDLE HMOpenMutex
2455	* Purpose : Wrapper for the OpenMutex() API
2456	* Parameters:
2457	* Variables :
2458	* Result :
2459	* Remark :
2460	* Status :
2461	*
2462	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2463	*****************************************************************************/
2464
2465	HANDLE HMOpenMutex(DWORD fdwAccess,
2466	BOOL fInherit,
2467	LPCTSTR lpName)
2468	{
2469	int iIndex; /* index into the handle table */
2470	int iIndexNew; /* index into the handle table */
2471	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2472	PHMHANDLEDATA pHMHandleData;
2473	DWORD rc; /* API return code */
2474
2475
2476	pDeviceHandler = HMGlobals.pHMMutex; /* device is predefined */
2477
2478	iIndexNew = _HMHandleGetFree(); /* get free handle */
2479	if (-1 == iIndexNew) /* oops, no free handles ! */
2480	{
2481	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2482	return 0; /* signal error */
2483	}
2484
2485
2486	/* initialize the complete HMHANDLEDATA structure */
2487	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2488	pHMHandleData->dwAccess = fdwAccess;
2489	pHMHandleData->dwShare = 0;
2490	pHMHandleData->dwCreation = 0;
2491	pHMHandleData->dwFlags = 0;
2492	pHMHandleData->lpHandlerData = NULL;
2493
2494
2495	/* we've got to mark the handle as occupied here, since another device */
2496	/* could be created within the device handler -> deadlock */
2497
2498	/* write appropriate entry into the handle table if open succeeded */
2499	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2500	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2501
2502	/* call the device handler */
2503	rc = pDeviceHandler->OpenMutex(&TabWin32Handles[iIndexNew].hmHandleData,
2504	fInherit,
2505	lpName);
2506	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2507	{
2508	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2509	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2510	return 0; /* signal error */
2511	}
2512	else
2513	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2514
2515	return iIndexNew; /* return valid handle */
2516	}
2517
2518
2519	/*****************************************************************************
2520	* Name : HANDLE HMCreateSemaphore
2521	* Purpose : Wrapper for the CreateSemaphore() API
2522	* Parameters:
2523	* Variables :
2524	* Result :
2525	* Remark :
2526	* Status :
2527	*
2528	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2529	*****************************************************************************/
2530
2531	HANDLE HMCreateSemaphore(LPSECURITY_ATTRIBUTES lpsa,
2532	LONG lInitialCount,
2533	LONG lMaximumCount,
2534	LPCTSTR lpName)
2535	{
2536	int iIndex; /* index into the handle table */
2537	int iIndexNew; /* index into the handle table */
2538	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2539	PHMHANDLEDATA pHMHandleData;
2540	DWORD rc; /* API return code */
2541
2542	if(lpName) { //check if shared event semaphore already exists
2543	//TODO: No inheritance??
2544	HANDLE handle = HMOpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, lpName);
2545	if(handle) {
2546	dprintf(("CreateSemaphore: return handle of existing semaphore %x", handle));
2547	SetLastError(ERROR_ALREADY_EXISTS);
2548	return handle;
2549	}
2550	}
2551
2552	pDeviceHandler = HMGlobals.pHMSemaphore; /* device is predefined */
2553
2554	iIndexNew = _HMHandleGetFree(); /* get free handle */
2555	if (-1 == iIndexNew) /* oops, no free handles ! */
2556	{
2557	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2558	return 0; /* signal error */
2559	}
2560
2561
2562	/* initialize the complete HMHANDLEDATA structure */
2563	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2564	pHMHandleData->dwAccess = 0;
2565	pHMHandleData->dwShare = 0;
2566	pHMHandleData->dwCreation = 0;
2567	pHMHandleData->dwFlags = 0;
2568	pHMHandleData->lpHandlerData = NULL;
2569
2570
2571	/* we've got to mark the handle as occupied here, since another device */
2572	/* could be created within the device handler -> deadlock */
2573
2574	/* write appropriate entry into the handle table if open succeeded */
2575	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2576	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2577
2578	/* call the device handler */
2579	rc = pDeviceHandler->CreateSemaphore(&TabWin32Handles[iIndexNew].hmHandleData,
2580	lpsa,
2581	lInitialCount,
2582	lMaximumCount,
2583	lpName);
2584	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2585	{
2586	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2587	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2588	return 0; /* signal failure */
2589	}
2590	else
2591	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2592
2593	return iIndexNew; /* return valid handle */
2594	}
2595
2596
2597	/*****************************************************************************
2598	* Name : HANDLE HMOpenSemaphore
2599	* Purpose : Wrapper for the OpenSemaphore() API
2600	* Parameters:
2601	* Variables :
2602	* Result :
2603	* Remark :
2604	* Status :
2605	*
2606	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2607	*****************************************************************************/
2608
2609	HANDLE HMOpenSemaphore(DWORD fdwAccess,
2610	BOOL fInherit,
2611	LPCTSTR lpName)
2612	{
2613	int iIndex; /* index into the handle table */
2614	int iIndexNew; /* index into the handle table */
2615	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2616	PHMHANDLEDATA pHMHandleData;
2617	DWORD rc; /* API return code */
2618
2619
2620	pDeviceHandler = HMGlobals.pHMSemaphore; /* device is predefined */
2621
2622	iIndexNew = _HMHandleGetFree(); /* get free handle */
2623	if (-1 == iIndexNew) /* oops, no free handles ! */
2624	{
2625	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2626	return 0; /* signal error */
2627	}
2628
2629
2630	/* initialize the complete HMHANDLEDATA structure */
2631	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2632	pHMHandleData->dwAccess = fdwAccess;
2633	pHMHandleData->dwShare = 0;
2634	pHMHandleData->dwCreation = 0;
2635	pHMHandleData->dwFlags = 0;
2636	pHMHandleData->lpHandlerData = NULL;
2637
2638
2639	/* we've got to mark the handle as occupied here, since another device */
2640	/* could be created within the device handler -> deadlock */
2641
2642	/* write appropriate entry into the handle table if open succeeded */
2643	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2644	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2645
2646	/* call the device handler */
2647	rc = pDeviceHandler->OpenSemaphore(&TabWin32Handles[iIndexNew].hmHandleData,
2648	fInherit,
2649	lpName);
2650	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2651	{
2652	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2653	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2654	return 0; /* signal failure */
2655	}
2656	else
2657	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2658
2659	return iIndexNew; /* return valid handle */
2660	}
2661
2662
2663	/*****************************************************************************
2664	* Name : HMReleaseSemaphore
2665	* Purpose : router function for ReleaseSemaphore
2666	* Parameters:
2667	* Variables :
2668	* Result :
2669	* Remark :
2670	* Status :
2671	*
2672	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2673	*****************************************************************************/
2674
2675	BOOL HMReleaseSemaphore(HANDLE hEvent,
2676	LONG cReleaseCount,
2677	LPLONG lpPreviousCount)
2678	{
2679	int iIndex; /* index into the handle table */
2680	DWORD dwResult; /* result from the device handler's API */
2681	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2682
2683	/* validate handle */
2684	iIndex = _HMHandleQuery(hEvent); /* get the index */
2685	if (-1 == iIndex) /* error ? */
2686	{
2687	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2688	return 0; /* signal failure */
2689	}
2690	else
2691	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2692
2693	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2694	dwResult = pHMHandle->pDeviceHandler->ReleaseSemaphore(&pHMHandle->hmHandleData,
2695	cReleaseCount,
2696	lpPreviousCount);
2697
2698	return (dwResult); /* deliver return code */
2699	}
2700
2701
2702	/*****************************************************************************
2703	* Name : HANDLE HMCreateFileMapping
2704	* Purpose : Wrapper for the CreateFileMapping() API
2705	* Parameters:
2706	* Variables :
2707	* Result :
2708	* Remark :
2709	* Status :
2710	*
2711	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2712	*****************************************************************************/
2713
2714	HANDLE HMCreateFileMapping(HANDLE hFile,
2715	LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
2716	DWORD flProtect,
2717	DWORD dwMaximumSizeHigh,
2718	DWORD dwMaximumSizeLow,
2719	LPCTSTR lpName)
2720	{
2721	int iIndex; /* index into the handle table */
2722	int iIndexNew; /* index into the handle table */
2723	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2724	PHMHANDLEDATA pHMHandleData;
2725	DWORD rc; /* API return code */
2726
2727	pDeviceHandler = HMGlobals.pHMFileMapping; /* device is predefined */
2728
2729	iIndexNew = _HMHandleGetFree(); /* get free handle */
2730	if (-1 == iIndexNew) /* oops, no free handles ! */
2731	{
2732	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2733	return 0; /* signal error */
2734	}
2735
2736	/* initialize the complete HMHANDLEDATA structure */
2737	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2738	pHMHandleData->dwAccess = 0;
2739	pHMHandleData->dwShare = 0;
2740	pHMHandleData->dwCreation = 0;
2741	pHMHandleData->dwFlags = 0;
2742	pHMHandleData->lpHandlerData = NULL;
2743
2744	/* we've got to mark the handle as occupied here, since another device */
2745	/* could be created within the device handler -> deadlock */
2746
2747	/* write appropriate entry into the handle table if open succeeded */
2748	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2749	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2750
2751	/* call the device handler */
2752
2753	// @@@PH: Note: hFile is a Win32-style handle, it's not (yet) converted to
2754	// a valid HandleManager-internal handle!
2755	rc = pDeviceHandler->CreateFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
2756	hFile,
2757	lpFileMappingAttributes,
2758	flProtect,
2759	dwMaximumSizeHigh,
2760	dwMaximumSizeLow,
2761	lpName);
2762
2763	if(rc != NO_ERROR) /* oops, creation failed within the device handler */
2764	{
2765	if(rc != ERROR_ALREADY_EXISTS) {
2766	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2767	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2768	return (NULL); /* signal error */
2769	}
2770	SetLastError(ERROR_ALREADY_EXISTS);
2771	return iIndexNew; /* return valid handle */
2772	}
2773	else
2774	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2775
2776	return iIndexNew; /* return valid handle */
2777	}
2778
2779
2780	/*****************************************************************************
2781	* Name : HANDLE HMOpenFileMapping
2782	* Purpose : Wrapper for the OpenFileMapping() API
2783	* Parameters:
2784	* Variables :
2785	* Result : HANDLE if succeeded,
2786	* NULL if failed.
2787	* Remark :
2788	* Status :
2789	*
2790	* Author : Patrick Haller [Wed, 1998/02/11 20:44]
2791	*****************************************************************************/
2792
2793	HANDLE HMOpenFileMapping(DWORD fdwAccess,
2794	BOOL fInherit,
2795	LPCTSTR lpName)
2796	{
2797	int iIndex; /* index into the handle table */
2798	int iIndexNew; /* index into the handle table */
2799	HMDeviceHandler pDeviceHandler; / device handler for this handle */
2800	PHMHANDLEDATA pHMHandleData;
2801	DWORD rc; /* API return code */
2802
2803
2804	pDeviceHandler = HMGlobals.pHMFileMapping; /* device is predefined */
2805
2806	iIndexNew = _HMHandleGetFree(); /* get free handle */
2807	if (-1 == iIndexNew) /* oops, no free handles ! */
2808	{
2809	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
2810	return (NULL); /* signal error */
2811	}
2812
2813	/* initialize the complete HMHANDLEDATA structure */
2814	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
2815	pHMHandleData->dwAccess = fdwAccess;
2816	pHMHandleData->dwShare = 0;
2817	pHMHandleData->dwCreation = 0;
2818	pHMHandleData->dwFlags = 0;
2819	pHMHandleData->lpHandlerData = NULL;
2820
2821
2822	/* we've got to mark the handle as occupied here, since another device */
2823	/* could be created within the device handler -> deadlock */
2824
2825	/* write appropriate entry into the handle table if open succeeded */
2826	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
2827	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
2828
2829	/* call the device handler */
2830	rc = pDeviceHandler->OpenFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
2831	fdwAccess,
2832	fInherit,
2833	lpName);
2834	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
2835	{
2836	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
2837	SetLastError(rc); /* Hehe, OS/2 and NT are pretty compatible :) */
2838	return (NULL); /* signal error */
2839	}
2840	else
2841	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
2842
2843	return iIndexNew; /* return valid handle */
2844	}
2845
2846
2847	/*****************************************************************************
2848	* Name : HMMapViewOfFileEx
2849	* Purpose : router function for MapViewOfFileEx
2850	* Parameters:
2851	* Variables :
2852	* Result :
2853	* Remark :
2854	* Status :
2855	*
2856	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2857	*****************************************************************************/
2858
2859	LPVOID HMMapViewOfFileEx(HANDLE hFileMappingObject,
2860	DWORD dwDesiredAccess,
2861	DWORD dwFileOffsetHigh,
2862	DWORD dwFileOffsetLow,
2863	DWORD dwNumberOfBytesToMap,
2864	LPVOID lpBaseAddress)
2865	{
2866	int iIndex; /* index into the handle table */
2867	LPVOID lpResult; /* result from the device handler's API */
2868	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2869
2870	/* validate handle */
2871	iIndex = _HMHandleQuery(hFileMappingObject); /* get the index */
2872	if (-1 == iIndex) /* error ? */
2873	{
2874	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
2875	return (NULL); /* signal failure */
2876	}
2877
2878	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2879	lpResult = pHMHandle->pDeviceHandler->MapViewOfFileEx(&pHMHandle->hmHandleData,
2880	dwDesiredAccess,
2881	dwFileOffsetHigh,
2882	dwFileOffsetLow,
2883	dwNumberOfBytesToMap,
2884	lpBaseAddress);
2885
2886	return (lpResult); /* deliver return code */
2887	}
2888
2889	/*****************************************************************************
2890	* Name : HMWaitForMultipleObjects
2891	* Purpose : router function for WaitForMultipleObjects
2892	* Parameters:
2893	* Variables :
2894	* Result :
2895	* Remark :
2896	* Status :
2897	*
2898	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
2899	*****************************************************************************/
2900
2901	DWORD HMWaitForMultipleObjects (DWORD cObjects,
2902	PHANDLE lphObjects,
2903	BOOL fWaitAll,
2904	DWORD dwTimeout)
2905	{
2906	#ifdef USE_OS2SEMAPHORES
2907	int iIndex; /* index into the handle table */
2908	DWORD dwResult; /* result from the device handler's API */
2909	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
2910
2911	if(cObjects == 1) {
2912	return HMWaitForSingleObject(*lphObjects, dwTimeout);
2913	}
2914
2915	if(cObjects > MAXIMUM_WAIT_OBJECTS) {
2916	dprintf(("KERNEL32: HMWaitForMultipleObjects: Too many objects (%d)", cObjects));
2917	SetLastError(ERROR_INVALID_PARAMETER);
2918	return WAIT_FAILED;
2919	}
2920
2921	/* validate handle */
2922	iIndex = _HMHandleQuery(lphObjects); / get the index */
2923	if (-1 == iIndex) /* error ? */
2924	{//oh, oh. possible problem here
2925	//TODO: rewrite handling of other handles; don't forward to open32
2926	dprintf(("WANRING: HMWaitForMultipleObjects: unknown handle passed on to Open32 -> will not work if other handles are semaphores"));
2927	return O32_WaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout);
2928	}
2929
2930	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
2931	dwResult = pHMHandle->pDeviceHandler->WaitForMultipleObjects(&pHMHandle->hmHandleData,
2932	cObjects, lphObjects, fWaitAll,
2933	dwTimeout);
2934
2935	return (dwResult); /* deliver return code */
2936	#else
2937	ULONG ulIndex;
2938	PHANDLE pArrayOfHandles;
2939	PHANDLE pLoop1 = lphObjects;
2940	PHANDLE pLoop2;
2941	DWORD rc;
2942
2943	// allocate array for handle table
2944	pArrayOfHandles = (PHANDLE)alloca(cObjects * sizeof(HANDLE));
2945	if (pArrayOfHandles == NULL)
2946	{
2947	dprintf(("ERROR: HMWaitForMultipleObjects: alloca failed to allocate %d handles", cObjects));
2948	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2949	return WAIT_FAILED;
2950	}
2951	else
2952	pLoop2 = pArrayOfHandles;
2953
2954	// convert array to odin handles
2955	for (ulIndex = 0;
2956
2957	ulIndex < cObjects;
2958
2959	ulIndex++,
2960	pLoop1++,
2961	pLoop2++)
2962	{
2963	rc = HMHandleTranslateToOS2 (*pLoop1, // translate handle
2964	pLoop2);
2965
2966	dprintf(("KERNEL32: HMWaitForMultipleObjects: handle %3i: ODIN-%08xh, Open32-%08xh\n",
2967	ulIndex,
2968	*pLoop1,
2969	*pLoop2));
2970
2971	// @@@PH to imlpement: check handle type!
2972	// SvL: We still use Open32 handles for threads & processes -> don't fail here!
2973	if (rc != NO_ERROR)
2974	{
2975	dprintf(("KERNEL32: HMWaitForMultipleObjects - WARNING: handle %08xh is NOT an Odin handle (probably Open32 thread or process)\n",
2976	*pLoop1));
2977
2978	pLoop2 = pLoop1;
2979	//// SetLastError(ERROR_INVALID_HANDLE);
2980	//// return (WAIT_FAILED);
2981	}
2982	}
2983
2984	// OK, now forward to Open32.
2985	// @@@PH: Note this will fail on handles that do NOT belong to Open32
2986	// but to i.e. the console subsystem!
2987	rc = O32_WaitForMultipleObjects(cObjects,
2988	pArrayOfHandles,
2989	fWaitAll,
2990	dwTimeout);
2991
2992	return (rc); // OK, done
2993	#endif
2994	}
2995
2996
2997	/*****************************************************************************
2998	* Name : HMWaitForMultipleObjectsEx
2999	* Purpose : router function for WaitForMultipleObjectsEx
3000	* Parameters:
3001	* Variables :
3002	* Result :
3003	* Remark :
3004	* Status :
3005	*
3006	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
3007	*****************************************************************************/
3008
3009	DWORD HMWaitForMultipleObjectsEx (DWORD cObjects,
3010	PHANDLE lphObjects,
3011	BOOL fWaitAll,
3012	DWORD dwTimeout,
3013	BOOL fAlertable)
3014	{
3015	// @@@PH: Note: fAlertable is ignored !
3016	return (HMWaitForMultipleObjects(cObjects,
3017	lphObjects,
3018	fWaitAll,
3019	dwTimeout));
3020	}
3021
3022	/*****************************************************************************
3023	* Name : HMMsgWaitForMultipleObjects
3024	* Purpose : router function for MsgWaitForMultipleObjects
3025	* Parameters:
3026	* Variables :
3027	* Result :
3028	* Remark : Open32 doesn't implement this properly! (doesn't check dwWakeMask)
3029	* Status :
3030	*
3031	* Author : Patrick Haller [Wed, 1999/06/17 20:44]
3032	*****************************************************************************/
3033
3034	DWORD HMMsgWaitForMultipleObjects (DWORD cObjects,
3035	LPHANDLE lphObjects,
3036	BOOL fWaitAll,
3037	DWORD dwTimeout,
3038	DWORD dwWakeMask)
3039	{
3040	#ifdef USE_OS2SEMAPHORES
3041	int iIndex; /* index into the handle table */
3042	DWORD dwResult; /* result from the device handler's API */
3043	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3044
3045
3046	if(dwWakeMask == 0) {
3047	dprintf(("WARNING: wakemask == 0 -> calling WaitForMultipleObjects"));
3048	return HMWaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout);
3049	}
3050	/* validate handle */
3051	iIndex = _HMHandleQuery(lphObjects); / get the index */
3052	if (-1 == iIndex) /* error ? */
3053	{//oh, oh. possible problem here
3054	//TODO: rewrite handling of other handles; don't forward to open32
3055	dprintf(("WANRING: HMWaitForMultipleObjects: unknown handle passed on to Open32 -> will not work if other handles are semaphores"));
3056	return O32_MsgWaitForMultipleObjects(cObjects, lphObjects, fWaitAll, dwTimeout, dwWakeMask);
3057	}
3058
3059	if(cObjects > MAXIMUM_WAIT_OBJECTS) {
3060	dprintf(("KERNEL32: HMMsgWaitForMultipleObjects: Too many objects (%d)", cObjects));
3061	SetLastError(ERROR_INVALID_PARAMETER);
3062	return WAIT_FAILED;
3063	}
3064
3065	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3066	dwResult = pHMHandle->pDeviceHandler->MsgWaitForMultipleObjects(&pHMHandle->hmHandleData,
3067	cObjects, lphObjects, fWaitAll,
3068	dwTimeout, dwWakeMask);
3069
3070	return (dwResult); /* deliver return code */
3071	#else
3072	ULONG ulIndex;
3073	PHANDLE pArrayOfHandles;
3074	PHANDLE pLoop1 = lphObjects;
3075	PHANDLE pLoop2;
3076	DWORD rc;
3077
3078	// allocate array for handle table
3079	pArrayOfHandles = (PHANDLE)alloca(cObjects * sizeof(HANDLE));
3080	if (pArrayOfHandles == NULL)
3081	{
3082	dprintf(("ERROR: HMMsgWaitForMultipleObjects: alloca failed to allocate %d handles", cObjects));
3083	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3084	return WAIT_FAILED;
3085	}
3086	else
3087	pLoop2 = pArrayOfHandles;
3088
3089	// convert array to odin handles
3090	for (ulIndex = 0;
3091
3092	ulIndex < cObjects;
3093
3094	ulIndex++,
3095	pLoop1++,
3096	pLoop2++)
3097	{
3098	rc = HMHandleTranslateToOS2 (*pLoop1, // translate handle
3099	pLoop2);
3100
3101	dprintf2(("MsgWaitForMultipleObjects handle %x->%x", pLoop1, pLoop2));
3102	// SvL: We still use Open32 handles for threads & processes -> don't fail here!
3103	if (rc != NO_ERROR)
3104	{
3105	dprintf(("KERNEL32: HMMsgWaitForMultipleObjects - WARNING: handle %08xh is NOT an Odin handle (probably Open32 thread or process)\n",
3106	*pLoop1));
3107
3108	pLoop2 = pLoop1;
3109	//// SetLastError(ERROR_INVALID_HANDLE);
3110	//// return (WAIT_FAILED);
3111	}
3112	}
3113
3114	// OK, now forward to Open32.
3115	// @@@PH: Note this will fail on handles that do NOT belong to Open32
3116	// but to i.e. the console subsystem!
3117	rc = O32_MsgWaitForMultipleObjects(cObjects,
3118	pArrayOfHandles,
3119	fWaitAll, dwTimeout,
3120	dwWakeMask);
3121
3122	dprintf2(("MsgWaitForMultipleObjects returned %d", rc));
3123	return (rc); // OK, done
3124	#endif
3125	}
3126	/*****************************************************************************
3127	* Name : HMDeviceIoControl
3128	* Purpose : router function for DeviceIoControl
3129	* Parameters:
3130	* Variables :
3131	* Result :
3132	* Remark :
3133	* Status :
3134	*
3135	* Author : Sander van Leeuwen
3136	*****************************************************************************/
3137
3138	BOOL HMDeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
3139	LPVOID lpInBuffer, DWORD nInBufferSize,
3140	LPVOID lpOutBuffer, DWORD nOutBufferSize,
3141	LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
3142	{
3143	int iIndex; /* index into the handle table */
3144	BOOL fResult; /* result from the device handler's CloseHandle() */
3145	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3146
3147	/* validate handle */
3148	iIndex = _HMHandleQuery(hDevice); /* get the index */
3149	if (-1 == iIndex) /* error ? */
3150	{
3151	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3152	return (FALSE); /* signal failure */
3153	}
3154
3155	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3156	fResult = pHMHandle->pDeviceHandler->DeviceIoControl(&pHMHandle->hmHandleData,
3157	dwIoControlCode,
3158	lpInBuffer, nInBufferSize,
3159	lpOutBuffer, nOutBufferSize,
3160	lpBytesReturned, lpOverlapped);
3161
3162	return (fResult); /* deliver return code */
3163	}
3164	/*****************************************************************************
3165	* Name : HMCancelIo
3166	* Purpose : router function for CancelIo
3167	* Parameters:
3168	* Variables :
3169	* Result :
3170	* Remark :
3171	* Status :
3172	*
3173	* Author : Sander van Leeuwen
3174	*****************************************************************************/
3175	BOOL HMCancelIo(HANDLE hDevice)
3176	{
3177	int iIndex; /* index into the handle table */
3178	BOOL fResult; /* result from the device handler's CloseHandle() */
3179	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3180
3181	/* validate handle */
3182	iIndex = _HMHandleQuery(hDevice); /* get the index */
3183	if (-1 == iIndex) /* error ? */
3184	{
3185	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3186	return (FALSE); /* signal failure */
3187	}
3188
3189	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3190	fResult = pHMHandle->pDeviceHandler->CancelIo(&pHMHandle->hmHandleData);
3191
3192	return (fResult); /* deliver return code */
3193	}
3194	/*****************************************************************************
3195	* Name : HMCOMGetCommState
3196	* Purpose : router function for GetCommState
3197	* Parameters:
3198	* Variables :
3199	* Result :
3200	* Remark :
3201	* Status :
3202	*
3203	* Author : Achim Hasenmueller [Sat, 1999/11/27 13:40]
3204	*****************************************************************************/
3205
3206	BOOL HMCommGetCommState(HANDLE hCommDev, LPDCB lpdcb)
3207	{
3208	int iIndex; /* index into the handle table */
3209	BOOL bResult; /* result from the device handler's API */
3210	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3211
3212	/* validate handle */
3213	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3214	if (-1 == iIndex) /* error ? */
3215	{
3216	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3217	return (NULL); /* signal failure */
3218	}
3219
3220	if(IsBadWritePtr(lpdcb,sizeof(DCB)))
3221	{
3222	SetLastError(ERROR_INVALID_PARAMETER);
3223	return FALSE;
3224	}
3225
3226	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3227	bResult = pHMHandle->pDeviceHandler->GetCommState(&pHMHandle->hmHandleData,
3228	lpdcb);
3229
3230	return (bResult); /* deliver return code */
3231	}
3232
3233	BOOL HMCommWaitCommEvent( HANDLE hCommDev,
3234	LPDWORD lpfdwEvtMask,
3235	LPOVERLAPPED lpo)
3236	{
3237	int iIndex; /* index into the handle table */
3238	BOOL bResult; /* result from the device handler's API */
3239	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3240
3241	/* validate handle */
3242	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3243	if (-1 == iIndex) /* error ? */
3244	{
3245	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3246	return FALSE; /* signal failure */
3247	}
3248
3249	if(NULL!=lpo && IsBadReadPtr(lpo,sizeof(OVERLAPPED)) )
3250	{
3251	SetLastError(ERROR_INVALID_PARAMETER);
3252	return FALSE;
3253	}
3254
3255	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3256	bResult = pHMHandle->pDeviceHandler->WaitCommEvent( &pHMHandle->hmHandleData,
3257	lpfdwEvtMask,
3258	lpo);
3259
3260	return (bResult); /* deliver return code */
3261	}
3262
3263	BOOL HMCommGetCommProperties( HANDLE hCommDev,
3264	LPCOMMPROP lpcmmp)
3265	{
3266	int iIndex; /* index into the handle table */
3267	BOOL bResult; /* result from the device handler's API */
3268	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3269
3270	/* validate handle */
3271	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3272	if (-1 == iIndex) /* error ? */
3273	{
3274	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3275	return (NULL); /* signal failure */
3276	}
3277
3278	if(IsBadWritePtr(lpcmmp,sizeof(COMMPROP)) )
3279	{
3280	SetLastError(ERROR_INVALID_PARAMETER);
3281	return FALSE;
3282	}
3283
3284	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3285	bResult = pHMHandle->pDeviceHandler->GetCommProperties( &pHMHandle->hmHandleData,
3286	lpcmmp);
3287
3288	return (bResult); /* deliver return code */
3289	}
3290
3291	BOOL HMCommGetCommMask( HANDLE hCommDev,
3292	LPDWORD lpfdwEvtMask)
3293	{
3294	int iIndex; /* index into the handle table */
3295	BOOL bResult; /* result from the device handler's API */
3296	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3297
3298	/* validate handle */
3299	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3300	if (-1 == iIndex) /* error ? */
3301	{
3302	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3303	return (NULL); /* signal failure */
3304	}
3305
3306	if(IsBadWritePtr(lpfdwEvtMask,sizeof(DWORD)) )
3307	{
3308	SetLastError(ERROR_INVALID_PARAMETER);
3309	return FALSE;
3310	}
3311
3312	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3313	bResult = pHMHandle->pDeviceHandler->GetCommMask( &pHMHandle->hmHandleData,
3314	lpfdwEvtMask);
3315
3316	return (bResult); /* deliver return code */
3317	}
3318
3319	BOOL HMCommSetCommMask( HANDLE hCommDev,
3320	DWORD fdwEvtMask)
3321	{
3322	int iIndex; /* index into the handle table */
3323	BOOL bResult; /* result from the device handler's API */
3324	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3325
3326	/* validate handle */
3327	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3328	if (-1 == iIndex) /* error ? */
3329	{
3330	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3331	return (NULL); /* signal failure */
3332	}
3333
3334	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3335	bResult = pHMHandle->pDeviceHandler->SetCommMask( &pHMHandle->hmHandleData,
3336	fdwEvtMask);
3337
3338	return (bResult); /* deliver return code */
3339	}
3340
3341	BOOL HMCommPurgeComm( HANDLE hCommDev,
3342	DWORD fdwAction)
3343	{
3344	int iIndex; /* index into the handle table */
3345	BOOL bResult; /* result from the device handler's API */
3346	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3347
3348	/* validate handle */
3349	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3350	if (-1 == iIndex) /* error ? */
3351	{
3352	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3353	return (NULL); /* signal failure */
3354	}
3355
3356
3357	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3358	bResult = pHMHandle->pDeviceHandler->PurgeComm( &pHMHandle->hmHandleData,
3359	fdwAction);
3360
3361	return (bResult); /* deliver return code */
3362	}
3363
3364	BOOL HMCommClearCommError( HANDLE hCommDev,
3365	LPDWORD lpdwErrors,
3366	LPCOMSTAT lpcst)
3367	{
3368	int iIndex; /* index into the handle table */
3369	BOOL bResult; /* result from the device handler's API */
3370	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3371
3372	/* validate handle */
3373	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3374	if (-1 == iIndex) /* error ? */
3375	{
3376	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3377	return (NULL); /* signal failure */
3378	}
3379
3380	if(IsBadWritePtr(lpdwErrors,sizeof(DWORD)) \|\|
3381	(NULL!=lpcst && IsBadWritePtr(lpcst,sizeof(COMSTAT)) ) )
3382	{
3383	SetLastError(ERROR_INVALID_PARAMETER);
3384	return FALSE;
3385	}
3386
3387	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3388	bResult = pHMHandle->pDeviceHandler->ClearCommError(&pHMHandle->hmHandleData,
3389	lpdwErrors,
3390	lpcst);
3391
3392	return (bResult); /* deliver return code */
3393	}
3394
3395	BOOL HMCommSetCommState( HANDLE hCommDev,
3396	LPDCB lpdcb)
3397	{
3398	int iIndex; /* index into the handle table */
3399	BOOL bResult; /* result from the device handler's API */
3400	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3401
3402	/* validate handle */
3403	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3404	if (-1 == iIndex) /* error ? */
3405	{
3406	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3407	return (NULL); /* signal failure */
3408	}
3409
3410	if(IsBadReadPtr(lpdcb,sizeof(DCB)) )
3411	{
3412	SetLastError(ERROR_INVALID_PARAMETER);
3413	return FALSE;
3414	}
3415
3416
3417	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3418	bResult = pHMHandle->pDeviceHandler->SetCommState(&pHMHandle->hmHandleData,
3419	lpdcb);
3420
3421	return (bResult); /* deliver return code */
3422	}
3423
3424
3425	BOOL HMCommGetCommTimeouts( HANDLE hCommDev,
3426	LPCOMMTIMEOUTS lpctmo)
3427	{
3428	int iIndex; /* index into the handle table */
3429	BOOL bResult; /* result from the device handler's API */
3430	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3431
3432	/* validate handle */
3433	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3434	if (-1 == iIndex) /* error ? */
3435	{
3436	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3437	return (NULL); /* signal failure */
3438	}
3439
3440	if(IsBadWritePtr(lpctmo,sizeof(COMMTIMEOUTS)) )
3441	{
3442	SetLastError(ERROR_INVALID_PARAMETER);
3443	return FALSE;
3444	}
3445
3446	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3447	bResult = pHMHandle->pDeviceHandler->GetCommTimeouts( &pHMHandle->hmHandleData,
3448	lpctmo);
3449
3450	return (bResult); /* deliver return code */
3451	}
3452	BOOL HMCommGetCommModemStatus( HANDLE hCommDev,
3453	LPDWORD lpModemStat )
3454	{
3455	int iIndex; /* index into the handle table */
3456	BOOL bResult; /* result from the device handler's API */
3457	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3458
3459	/* validate handle */
3460	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3461	if (-1 == iIndex) /* error ? */
3462	{
3463	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3464	return (NULL); /* signal failure */
3465	}
3466
3467	if(IsBadWritePtr(lpModemStat,sizeof(DWORD)) )
3468	{
3469	SetLastError(ERROR_INVALID_PARAMETER);
3470	return FALSE;
3471	}
3472
3473	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3474	bResult = pHMHandle->pDeviceHandler->GetCommModemStatus( &pHMHandle->hmHandleData,
3475	lpModemStat);
3476
3477	return (bResult); /* deliver return code */
3478	}
3479
3480	BOOL HMCommSetCommTimeouts( HANDLE hCommDev,
3481	LPCOMMTIMEOUTS lpctmo)
3482	{
3483	int iIndex; /* index into the handle table */
3484	BOOL bResult; /* result from the device handler's API */
3485	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3486
3487	/* validate handle */
3488	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3489	if (-1 == iIndex) /* error ? */
3490	{
3491	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3492	return (NULL); /* signal failure */
3493	}
3494
3495	if(IsBadReadPtr(lpctmo,sizeof(COMMTIMEOUTS)) )
3496	{
3497	SetLastError(ERROR_INVALID_PARAMETER);
3498	return FALSE;
3499	}
3500
3501	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3502	bResult = pHMHandle->pDeviceHandler->SetCommTimeouts( &pHMHandle->hmHandleData,
3503	lpctmo);
3504
3505	return (bResult); /* deliver return code */
3506	}
3507
3508	BOOL HMCommTransmitCommChar( HANDLE hCommDev,
3509	CHAR cChar )
3510	{
3511	int iIndex; /* index into the handle table */
3512	BOOL bResult; /* result from the device handler's API */
3513	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3514
3515	/* validate handle */
3516	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3517	if (-1 == iIndex) /* error ? */
3518	{
3519	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3520	return (NULL); /* signal failure */
3521	}
3522
3523	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3524	bResult = pHMHandle->pDeviceHandler->TransmitCommChar( &pHMHandle->hmHandleData,
3525	cChar);
3526
3527	return (bResult); /* deliver return code */
3528	}
3529
3530	BOOL HMCommSetCommConfig( HANDLE hCommDev,
3531	LPCOMMCONFIG lpCC,
3532	DWORD dwSize )
3533	{
3534	int iIndex; /* index into the handle table */
3535	BOOL bResult; /* result from the device handler's API */
3536	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3537
3538	/* validate handle */
3539	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3540	if (-1 == iIndex) /* error ? */
3541	{
3542	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3543	return (NULL); /* signal failure */
3544	}
3545
3546	if( IsBadReadPtr(lpCC,sizeof(COMMCONFIG)) \|\|
3547	dwSize < sizeof(COMMCONFIG) )
3548	{
3549	SetLastError(ERROR_INVALID_PARAMETER);
3550	return FALSE;
3551	}
3552
3553	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3554	bResult = pHMHandle->pDeviceHandler->SetCommConfig( &pHMHandle->hmHandleData,
3555	lpCC,
3556	dwSize);
3557
3558	return (bResult); /* deliver return code */
3559	}
3560
3561	BOOL HMCommSetCommBreak( HANDLE hCommDev )
3562	{
3563	int iIndex; /* index into the handle table */
3564	BOOL bResult; /* result from the device handler's API */
3565	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3566
3567	/* validate handle */
3568	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3569	if (-1 == iIndex) /* error ? */
3570	{
3571	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3572	return (NULL); /* signal failure */
3573	}
3574
3575	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3576	bResult = pHMHandle->pDeviceHandler->SetCommBreak( &pHMHandle->hmHandleData);
3577
3578	return (bResult); /* deliver return code */
3579	}
3580
3581	BOOL HMCommGetCommConfig( HANDLE hCommDev,
3582	LPCOMMCONFIG lpCC,
3583	LPDWORD lpdwSize )
3584	{
3585	int iIndex; /* index into the handle table */
3586	BOOL bResult; /* result from the device handler's API */
3587	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3588
3589	/* validate handle */
3590	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3591	if (-1 == iIndex) /* error ? */
3592	{
3593	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3594	return (NULL); /* signal failure */
3595	}
3596
3597	if(IsBadWritePtr(lpdwSize,sizeof(DWORD)) )
3598	{
3599	SetLastError(ERROR_INVALID_PARAMETER);
3600	return FALSE;
3601	}
3602
3603	if( IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) \|\|
3604	*lpdwSize< sizeof(COMMCONFIG) )
3605	{
3606	SetLastError(ERROR_INSUFFICIENT_BUFFER);
3607	*lpdwSize= sizeof(COMMCONFIG);
3608	return FALSE;
3609	}
3610
3611	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3612	bResult = pHMHandle->pDeviceHandler->GetCommConfig( &pHMHandle->hmHandleData,
3613	lpCC,
3614	lpdwSize);
3615
3616	return (bResult); /* deliver return code */
3617	}
3618
3619	BOOL HMCommEscapeCommFunction( HANDLE hCommDev,
3620	UINT dwFunc )
3621	{
3622	int iIndex; /* index into the handle table */
3623	BOOL bResult; /* result from the device handler's API */
3624	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3625
3626	/* validate handle */
3627	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3628	if (-1 == iIndex) /* error ? */
3629	{
3630	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3631	return (NULL); /* signal failure */
3632	}
3633
3634	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3635
3636	switch(dwFunc)
3637	{
3638	case CLRDTR:
3639	case CLRRTS:
3640	case SETDTR:
3641	case SETRTS:
3642	case SETXOFF:
3643	case SETXON:
3644	bResult = pHMHandle->pDeviceHandler->EscapeCommFunction( &pHMHandle->hmHandleData,
3645	dwFunc);
3646	break;
3647	case SETBREAK:
3648	bResult = pHMHandle->pDeviceHandler->SetCommBreak(&pHMHandle->hmHandleData);
3649	break;
3650	case CLRBREAK:
3651	bResult = pHMHandle->pDeviceHandler->ClearCommBreak(&pHMHandle->hmHandleData);
3652	break;
3653	default:
3654	SetLastError(ERROR_INVALID_PARAMETER);
3655	bResult = FALSE;
3656	}
3657
3658
3659	return (bResult); /* deliver return code */
3660	}
3661
3662	BOOL HMCommSetupComm( HANDLE hCommDev,
3663	DWORD dwInQueue,
3664	DWORD dwOutQueue)
3665	{
3666	int iIndex; /* index into the handle table */
3667	BOOL bResult; /* result from the device handler's API */
3668	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3669
3670	/* validate handle */
3671	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3672	if (-1 == iIndex) /* error ? */
3673	{
3674	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3675	return (NULL); /* signal failure */
3676	}
3677
3678	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3679	bResult = pHMHandle->pDeviceHandler->SetupComm(&pHMHandle->hmHandleData,
3680	dwInQueue,
3681	dwOutQueue);
3682
3683	return (bResult); /* deliver return code */
3684	}
3685
3686	BOOL HMCommClearCommBreak(HANDLE hCommDev)
3687	{
3688	int iIndex; /* index into the handle table */
3689	BOOL bResult; /* result from the device handler's API */
3690	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3691
3692	/* validate handle */
3693	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3694	if (-1 == iIndex) /* error ? */
3695	{
3696	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3697	return (NULL); /* signal failure */
3698	}
3699
3700	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3701	bResult = pHMHandle->pDeviceHandler->ClearCommBreak(&pHMHandle->hmHandleData);
3702
3703	return (bResult); /* deliver return code */
3704	}
3705
3706	BOOL HMCommSetDefaultCommConfig( HANDLE hCommDev,
3707	LPCOMMCONFIG lpCC,
3708	DWORD dwSize)
3709	{
3710	int iIndex; /* index into the handle table */
3711	BOOL bResult; /* result from the device handler's API */
3712	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3713
3714	/* validate handle */
3715	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3716	if (-1 == iIndex) /* error ? */
3717	{
3718	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3719	return (NULL); /* signal failure */
3720	}
3721
3722	if( (lpCC!=NULL) &&
3723	( IsBadReadPtr(lpCC,sizeof(COMMCONFIG)) \|\|
3724	dwSize != sizeof(COMMCONFIG) ) )
3725	{
3726	SetLastError(ERROR_INVALID_PARAMETER);
3727	return FALSE;
3728	}
3729
3730	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3731	bResult = pHMHandle->pDeviceHandler->SetDefaultCommConfig(&pHMHandle->hmHandleData,
3732	lpCC,
3733	dwSize);
3734
3735	return (bResult); /* deliver return code */
3736	}
3737
3738	BOOL HMCommGetDefaultCommConfig( HANDLE hCommDev,
3739	LPCOMMCONFIG lpCC,
3740	LPDWORD lpdwSize)
3741	{
3742	int iIndex; /* index into the handle table */
3743	BOOL bResult; /* result from the device handler's API */
3744	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3745
3746	/* validate handle */
3747	iIndex = _HMHandleQuery(hCommDev); /* get the index */
3748	if (-1 == iIndex) /* error ? */
3749	{
3750	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3751	return (NULL); /* signal failure */
3752	}
3753
3754	if(IsBadWritePtr(lpdwSize,sizeof(DWORD)))
3755	{
3756	SetLastError(ERROR_INVALID_PARAMETER);
3757	return FALSE;
3758	}
3759
3760	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3761	bResult = pHMHandle->pDeviceHandler->GetDefaultCommConfig( &pHMHandle->hmHandleData,
3762	lpCC,
3763	lpdwSize);
3764
3765	return (bResult); /* deliver return code */
3766	}
3767
3768	/*****************************************************************************
3769	* Name : HMOpenThreadToken
3770	* Purpose : router function for NtOpenThreadToken
3771	* Parameters:
3772	* Variables :
3773	* Result :
3774	* Remark :
3775	* Status :
3776	*
3777	* Author : SvL
3778	*****************************************************************************/
3779
3780	DWORD HMOpenThreadToken(HANDLE ThreadHandle,
3781	DWORD DesiredAccess,
3782	DWORD OpenAsSelf,
3783	HANDLE *TokenHandle)
3784	{
3785	int iIndex; /* index into the handle table */
3786	int iIndexNew; /* index into the handle table */
3787	HMDeviceHandler pDeviceHandler; / device handler for this handle */
3788	PHMHANDLEDATA pHMHandleData;
3789	DWORD rc; /* API return code */
3790
3791	pDeviceHandler = HMGlobals.pHMToken; /* device is predefined */
3792
3793	iIndexNew = _HMHandleGetFree(); /* get free handle */
3794	if (-1 == iIndexNew) /* oops, no free handles ! */
3795	{
3796	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
3797	return ERROR_NOT_ENOUGH_MEMORY;
3798	}
3799
3800	/* initialize the complete HMHANDLEDATA structure */
3801	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
3802	pHMHandleData->dwAccess = DesiredAccess;
3803	pHMHandleData->dwShare = 0;
3804	pHMHandleData->dwCreation = 0;
3805	pHMHandleData->dwFlags = 0;
3806	pHMHandleData->lpHandlerData = NULL;
3807
3808
3809	/* we've got to mark the handle as occupied here, since another device */
3810	/* could be created within the device handler -> deadlock */
3811
3812	/* write appropriate entry into the handle table if open succeeded */
3813	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
3814	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
3815
3816	/* call the device handler */
3817
3818	// @@@PH: Note: hFile is a Win32-style handle, it's not (yet) converted to
3819	// a valid HandleManager-internal handle!
3820	rc = pDeviceHandler->OpenThreadToken(&TabWin32Handles[iIndexNew].hmHandleData,
3821	ThreadHandle,
3822	OpenAsSelf);
3823
3824	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
3825	{
3826	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
3827	return (rc); /* signal error */
3828	}
3829	else
3830	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
3831
3832	TokenHandle = iIndexNew; / return valid handle */
3833	return STATUS_SUCCESS;
3834	}
3835
3836	/*****************************************************************************
3837	* Name : HMOpenProcessToken
3838	* Purpose : router function for NtOpenProcessToken
3839	* Parameters:
3840	* Variables :
3841	* Result :
3842	* Remark :
3843	* Status :
3844	*
3845	* Author : SvL
3846	*****************************************************************************/
3847	DWORD HMOpenProcessToken(HANDLE ProcessHandle,
3848	DWORD DesiredAccess,
3849	DWORD dwUserData,
3850	HANDLE *TokenHandle)
3851	{
3852	int iIndex; /* index into the handle table */
3853	int iIndexNew; /* index into the handle table */
3854	HMDeviceHandler pDeviceHandler; / device handler for this handle */
3855	PHMHANDLEDATA pHMHandleData;
3856	DWORD rc; /* API return code */
3857
3858	pDeviceHandler = HMGlobals.pHMToken; /* device is predefined */
3859
3860	iIndexNew = _HMHandleGetFree(); /* get free handle */
3861	if (-1 == iIndexNew) /* oops, no free handles ! */
3862	{
3863	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
3864	return ERROR_NOT_ENOUGH_MEMORY;
3865	}
3866
3867	/* initialize the complete HMHANDLEDATA structure */
3868	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
3869	pHMHandleData->dwAccess = DesiredAccess;
3870	pHMHandleData->dwShare = 0;
3871	pHMHandleData->dwCreation = 0;
3872	pHMHandleData->dwFlags = 0;
3873	pHMHandleData->lpHandlerData = NULL;
3874
3875
3876	/* we've got to mark the handle as occupied here, since another device */
3877	/* could be created within the device handler -> deadlock */
3878
3879	/* write appropriate entry into the handle table if open succeeded */
3880	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
3881	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
3882
3883	/* call the device handler */
3884
3885	// @@@PH: Note: hFile is a Win32-style handle, it's not (yet) converted to
3886	// a valid HandleManager-internal handle!
3887	rc = pDeviceHandler->OpenProcessToken(&TabWin32Handles[iIndexNew].hmHandleData,
3888	dwUserData,
3889	ProcessHandle);
3890
3891	if (rc != NO_ERROR) /* oops, creation failed within the device handler */
3892	{
3893	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
3894	return (rc); /* signal error */
3895	}
3896	else
3897	SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
3898
3899	TokenHandle = iIndexNew; / return valid handle */
3900	return STATUS_SUCCESS;
3901	}
3902	/*****************************************************************************
3903	* Name : HMCreateThread
3904	* Purpose : router function for CreateThread
3905	* Parameters:
3906	* Variables :
3907	* Result :
3908	* Remark :
3909	* Status :
3910	*
3911	* Author : SvL
3912	*****************************************************************************/
3913	HANDLE HMCreateThread(LPSECURITY_ATTRIBUTES lpsa,
3914	DWORD cbStack,
3915	LPTHREAD_START_ROUTINE lpStartAddr,
3916	LPVOID lpvThreadParm,
3917	DWORD fdwCreate,
3918	LPDWORD lpIDThread,
3919	BOOL fFirstThread)
3920	{
3921	int iIndex; /* index into the handle table */
3922	int iIndexNew; /* index into the handle table */
3923	HMDeviceHandler pDeviceHandler; / device handler for this handle */
3924	PHMHANDLEDATA pHMHandleData;
3925	HANDLE rc; /* API return code */
3926
3927	SetLastError(ERROR_SUCCESS);
3928
3929	pDeviceHandler = HMGlobals.pHMThread; /* device is predefined */
3930
3931	iIndexNew = _HMHandleGetFree(); /* get free handle */
3932	if (-1 == iIndexNew) /* oops, no free handles ! */
3933	{
3934	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
3935	return 0;
3936	}
3937
3938	/* initialize the complete HMHANDLEDATA structure */
3939	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
3940	pHMHandleData->dwAccess = 0;
3941	pHMHandleData->dwShare = 0;
3942	pHMHandleData->dwCreation = 0;
3943	pHMHandleData->dwFlags = 0;
3944	pHMHandleData->lpHandlerData = NULL;
3945
3946
3947	/* we've got to mark the handle as occupied here, since another device */
3948	/* could be created within the device handler -> deadlock */
3949
3950	/* write appropriate entry into the handle table if open succeeded */
3951	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
3952	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
3953
3954	/* call the device handler */
3955
3956	// @@@PH: Note: hFile is a Win32-style handle, it's not (yet) converted to
3957	// a valid HandleManager-internal handle!
3958	rc = pDeviceHandler->CreateThread(&TabWin32Handles[iIndexNew].hmHandleData,
3959	lpsa, cbStack, lpStartAddr,
3960	lpvThreadParm, fdwCreate, lpIDThread, fFirstThread);
3961
3962	if (rc == 0) /* oops, creation failed within the device handler */
3963	{
3964	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
3965	return 0; /* signal error */
3966	}
3967
3968	return iIndexNew;
3969	}
3970	/*****************************************************************************
3971	* Name : HMGetThreadPriority
3972	* Purpose : router function for GetThreadPriority
3973	* Parameters:
3974	* Variables :
3975	* Result :
3976	* Remark :
3977	* Status :
3978	*
3979	* Author : SvL
3980	*****************************************************************************/
3981	INT HMGetThreadPriority(HANDLE hThread)
3982	{
3983	int iIndex; /* index into the handle table */
3984	INT lpResult; /* result from the device handler's API */
3985	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
3986
3987	SetLastError(ERROR_SUCCESS);
3988	/* validate handle */
3989	iIndex = _HMHandleQuery(hThread); /* get the index */
3990	if (-1 == iIndex) /* error ? */
3991	{
3992	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
3993	return (-1); /* signal failure */
3994	}
3995
3996	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
3997	lpResult = pHMHandle->pDeviceHandler->GetThreadPriority(hThread, &TabWin32Handles[iIndex].hmHandleData);
3998
3999	return (lpResult); /* deliver return code */
4000	}
4001	/*****************************************************************************
4002	* Name : HMSuspendThread
4003	* Purpose : router function for SuspendThread
4004	* Parameters:
4005	* Variables :
4006	* Result :
4007	* Remark :
4008	* Status :
4009	*
4010	* Author : SvL
4011	*****************************************************************************/
4012	DWORD HMSuspendThread(HANDLE hThread)
4013	{
4014	int iIndex; /* index into the handle table */
4015	HANDLE lpResult; /* result from the device handler's API */
4016	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4017
4018	SetLastError(ERROR_SUCCESS);
4019	/* validate handle */
4020	iIndex = _HMHandleQuery(hThread); /* get the index */
4021	if (-1 == iIndex) /* error ? */
4022	{
4023	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4024	return -1; /* signal failure */
4025	}
4026
4027	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4028	lpResult = pHMHandle->pDeviceHandler->SuspendThread(hThread, &TabWin32Handles[iIndex].hmHandleData);
4029
4030	return (lpResult); /* deliver return code */
4031	}
4032	/*****************************************************************************
4033	* Name : HMSetThreadPriority
4034	* Purpose : router function for SetThreadPriority
4035	* Parameters:
4036	* Variables :
4037	* Result :
4038	* Remark :
4039	* Status :
4040	*
4041	* Author : SvL
4042	*****************************************************************************/
4043	BOOL HMSetThreadPriority(HANDLE hThread, int priority)
4044	{
4045	int iIndex; /* index into the handle table */
4046	BOOL lpResult; /* result from the device handler's API */
4047	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4048
4049	SetLastError(ERROR_SUCCESS);
4050	/* validate handle */
4051	iIndex = _HMHandleQuery(hThread); /* get the index */
4052	if (-1 == iIndex) /* error ? */
4053	{
4054	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4055	return FALSE; /* signal failure */
4056	}
4057
4058	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4059	lpResult = pHMHandle->pDeviceHandler->SetThreadPriority(hThread, &TabWin32Handles[iIndex].hmHandleData, priority);
4060
4061	return (lpResult); /* deliver return code */
4062	}
4063	/*****************************************************************************
4064	* Name : HMGetThreadContext
4065	* Purpose : router function for GetThreadContext
4066	* Parameters:
4067	* Variables :
4068	* Result :
4069	* Remark :
4070	* Status :
4071	*
4072	* Author : SvL
4073	*****************************************************************************/
4074	BOOL HMGetThreadContext(HANDLE hThread, CONTEXT *lpContext)
4075	{
4076	int iIndex; /* index into the handle table */
4077	BOOL lpResult; /* result from the device handler's API */
4078	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4079
4080	SetLastError(ERROR_SUCCESS);
4081	/* validate handle */
4082	iIndex = _HMHandleQuery(hThread); /* get the index */
4083	if (-1 == iIndex) /* error ? */
4084	{
4085	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4086	return FALSE; /* signal failure */
4087	}
4088
4089	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4090	lpResult = pHMHandle->pDeviceHandler->GetThreadContext(hThread, &TabWin32Handles[iIndex].hmHandleData, lpContext);
4091
4092	return (lpResult); /* deliver return code */
4093	}
4094	/*****************************************************************************
4095	* Name : HMSetThreadContext
4096	* Purpose : router function for SetThreadContext
4097	* Parameters:
4098	* Variables :
4099	* Result :
4100	* Remark :
4101	* Status :
4102	*
4103	* Author : SvL
4104	*****************************************************************************/
4105	BOOL HMSetThreadContext(HANDLE hThread, const CONTEXT *lpContext)
4106	{
4107	int iIndex; /* index into the handle table */
4108	BOOL lpResult; /* result from the device handler's API */
4109	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4110
4111	SetLastError(ERROR_SUCCESS);
4112	/* validate handle */
4113	iIndex = _HMHandleQuery(hThread); /* get the index */
4114	if (-1 == iIndex) /* error ? */
4115	{
4116	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4117	return FALSE; /* signal failure */
4118	}
4119
4120	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4121	lpResult = pHMHandle->pDeviceHandler->SetThreadContext(hThread, &TabWin32Handles[iIndex].hmHandleData, lpContext);
4122
4123	return (lpResult); /* deliver return code */
4124	}
4125	/*****************************************************************************
4126	* Name : HMTerminateThread
4127	* Purpose : router function for TerminateThread
4128	* Parameters:
4129	* Variables :
4130	* Result :
4131	* Remark :
4132	* Status :
4133	*
4134	* Author : SvL
4135	*****************************************************************************/
4136	BOOL HMTerminateThread(HANDLE hThread, DWORD exitcode)
4137	{
4138	int iIndex; /* index into the handle table */
4139	BOOL lpResult; /* result from the device handler's API */
4140	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4141
4142	SetLastError(ERROR_SUCCESS);
4143	/* validate handle */
4144	iIndex = _HMHandleQuery(hThread); /* get the index */
4145	if (-1 == iIndex) /* error ? */
4146	{
4147	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4148	return FALSE; /* signal failure */
4149	}
4150
4151	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4152	lpResult = pHMHandle->pDeviceHandler->TerminateThread(hThread, &TabWin32Handles[iIndex].hmHandleData, exitcode);
4153
4154	return (lpResult); /* deliver return code */
4155	}
4156	/*****************************************************************************
4157	* Name : HMResumeThread
4158	* Purpose : router function for ResumeThread
4159	* Parameters:
4160	* Variables :
4161	* Result :
4162	* Remark :
4163	* Status :
4164	*
4165	* Author : SvL
4166	*****************************************************************************/
4167	DWORD HMResumeThread(HANDLE hThread)
4168	{
4169	int iIndex; /* index into the handle table */
4170	DWORD lpResult; /* result from the device handler's API */
4171	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4172
4173	SetLastError(ERROR_SUCCESS);
4174	/* validate handle */
4175	iIndex = _HMHandleQuery(hThread); /* get the index */
4176	if (-1 == iIndex) /* error ? */
4177	{
4178	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4179	return -1; /* signal failure */
4180	}
4181
4182	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4183	lpResult = pHMHandle->pDeviceHandler->ResumeThread(hThread, &TabWin32Handles[iIndex].hmHandleData);
4184
4185	return (lpResult); /* deliver return code */
4186	}
4187
4188	/*****************************************************************************
4189	* Name : HMGetExitCodeThread
4190	* Purpose : router function for GetExitCodeThread
4191	* Parameters:
4192	* Variables :
4193	* Result :
4194	* Remark :
4195	* Status :
4196	*
4197	* Author : SvL
4198	*****************************************************************************/
4199	BOOL HMGetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode)
4200	{
4201	int iIndex; /* index into the handle table */
4202	BOOL lpResult; /* result from the device handler's API */
4203	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4204
4205	SetLastError(ERROR_SUCCESS);
4206	/* validate handle */
4207	iIndex = _HMHandleQuery(hThread); /* get the index */
4208	if (-1 == iIndex) /* error ? */
4209	{
4210	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4211	return FALSE; /* signal failure */
4212	}
4213
4214	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4215	lpResult = pHMHandle->pDeviceHandler->GetExitCodeThread(hThread, &TabWin32Handles[iIndex].hmHandleData, lpExitCode);
4216
4217	return (lpResult); /* deliver return code */
4218	}
4219	/*****************************************************************************
4220	* Name : HMSetThreadTerminated
4221	* Purpose :
4222	* Parameters:
4223	* Variables :
4224	* Result :
4225	* Remark :
4226	* Status :
4227	*
4228	* Author : SvL
4229	*****************************************************************************/
4230	BOOL HMSetThreadTerminated(HANDLE hThread)
4231	{
4232	int iIndex; /* index into the handle table */
4233	BOOL lpResult; /* result from the device handler's API */
4234	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4235
4236	SetLastError(ERROR_SUCCESS);
4237	/* validate handle */
4238	iIndex = _HMHandleQuery(hThread); /* get the index */
4239	if (-1 == iIndex) /* error ? */
4240	{
4241	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4242	return FALSE; /* signal failure */
4243	}
4244
4245	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4246	lpResult = pHMHandle->pDeviceHandler->SetThreadTerminated(hThread, &TabWin32Handles[iIndex].hmHandleData);
4247
4248	return (lpResult); /* deliver return code */
4249	}
4250
4251	/*****************************************************************************
4252	* Name : HMPeekNamedPipe
4253	* Purpose :
4254	* Parameters:
4255	* Variables :
4256	* Result :
4257	* Remark :
4258	* Status :
4259	*
4260	* Author : Przemyslaw Dobrowolski
4261	*****************************************************************************/
4262	BOOL HMPeekNamedPipe(HANDLE hPipe,
4263	LPVOID lpvBuffer,
4264	DWORD cbBuffer,
4265	LPDWORD lpcbRead,
4266	LPDWORD lpcbAvail,
4267	LPDWORD lpcbMessage)
4268	{
4269	int iIndex; /* index into the handle table */
4270	BOOL lpResult; /* result from the device handler's API */
4271	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4272
4273	SetLastError(ERROR_SUCCESS);
4274	/* validate handle */
4275	iIndex = _HMHandleQuery(hPipe); /* get the index */
4276	if (-1 == iIndex) /* error ? */
4277	{
4278	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4279	return FALSE; /* signal failure */
4280	}
4281
4282	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4283	lpResult = pHMHandle->pDeviceHandler->PeekNamedPipe(&TabWin32Handles[iIndex].hmHandleData,
4284	lpvBuffer,
4285	cbBuffer,
4286	lpcbRead,
4287	lpcbAvail,
4288	lpcbMessage);
4289
4290	return (lpResult); /* deliver return code */
4291	}
4292
4293	/*****************************************************************************
4294	* Name : HMCreateNamedPipe
4295	* Purpose :
4296	* Parameters:
4297	* Variables :
4298	* Result :
4299	* Remark :
4300	* Status :
4301	*
4302	* Author : Przemyslaw Dobrowolski
4303	*****************************************************************************/
4304	DWORD HMCreateNamedPipe(LPCTSTR lpName,
4305	DWORD dwOpenMode,
4306	DWORD dwPipeMode,
4307	DWORD nMaxInstances,
4308	DWORD nOutBufferSize,
4309	DWORD nInBufferSize,
4310	DWORD nDefaultTimeOut,
4311	LPSECURITY_ATTRIBUTES lpSecurityAttributes)
4312	{
4313	int iIndex; /* index into the handle table */
4314	int iIndexNew; /* index into the handle table */
4315	HMDeviceHandler pDeviceHandler; / device handler for this handle */
4316	PHMHANDLEDATA pHMHandleData;
4317	HANDLE rc; /* API return code */
4318
4319	SetLastError(ERROR_SUCCESS);
4320
4321	pDeviceHandler = HMGlobals.pHMNamedPipe; /* device is predefined */
4322
4323	iIndexNew = _HMHandleGetFree(); /* get free handle */
4324	if (-1 == iIndexNew) /* oops, no free handles ! */
4325	{
4326	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
4327	return 0;
4328	}
4329
4330	/* initialize the complete HMHANDLEDATA structure */
4331	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
4332	pHMHandleData->dwAccess = 0;
4333	pHMHandleData->dwShare = 0;
4334	pHMHandleData->dwCreation = 0;
4335	pHMHandleData->dwFlags = 0;
4336	pHMHandleData->lpHandlerData = NULL;
4337
4338	/* we've got to mark the handle as occupied here, since another device */
4339	/* could be created within the device handler -> deadlock */
4340
4341	/* write appropriate entry into the handle table if open succeeded */
4342	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
4343	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
4344
4345	/* call the device handler */
4346
4347	rc = pDeviceHandler->CreateNamedPipe(&TabWin32Handles[iIndexNew].hmHandleData,
4348	lpName,dwOpenMode,
4349	dwPipeMode,nMaxInstances,
4350	nOutBufferSize,nInBufferSize,
4351	nDefaultTimeOut,lpSecurityAttributes);
4352
4353	if (rc == -1) /* oops, creation failed within the device handler */
4354	{
4355	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
4356	return 0; /* signal error */
4357	}
4358
4359	return iIndexNew;
4360	}
4361
4362	/*****************************************************************************
4363	* Name : HMConnectNamedPipe
4364	* Purpose :
4365	* Parameters:
4366	* Variables :
4367	* Result :
4368	* Remark :
4369	* Status :
4370	*
4371	* Author : Przemyslaw Dobrowolski
4372	*****************************************************************************/
4373	BOOL HMConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED lpOverlapped)
4374	{
4375	int iIndex; /* index into the handle table */
4376	BOOL lpResult; /* result from the device handler's API */
4377	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4378
4379	SetLastError(ERROR_SUCCESS);
4380	/* validate handle */
4381	iIndex = _HMHandleQuery(hPipe); /* get the index */
4382	if (-1 == iIndex) /* error ? */
4383	{
4384	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4385	return FALSE; /* signal failure */
4386	}
4387
4388	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4389	lpResult = pHMHandle->pDeviceHandler->ConnectNamedPipe(&TabWin32Handles[iIndex].hmHandleData,
4390	lpOverlapped);
4391
4392	return (lpResult); /* deliver return code */
4393	}
4394
4395	/*****************************************************************************
4396	* Name : HMDisconnectNamedPipe
4397	* Purpose :
4398	* Parameters:
4399	* Variables :
4400	* Result :
4401	* Remark :
4402	* Status :
4403	*
4404	* Author : Przemyslaw Dobrowolski
4405	*****************************************************************************/
4406	BOOL HMDisconnectNamedPipe(HANDLE hPipe)
4407	{
4408	int iIndex; /* index into the handle table */
4409	BOOL lpResult; /* result from the device handler's API */
4410	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4411
4412	SetLastError(ERROR_SUCCESS);
4413	/* validate handle */
4414	iIndex = _HMHandleQuery(hPipe); /* get the index */
4415	if (-1 == iIndex) /* error ? */
4416	{
4417	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4418	return FALSE; /* signal failure */
4419	}
4420
4421	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4422	lpResult = pHMHandle->pDeviceHandler->DisconnectNamedPipe(&TabWin32Handles[iIndex].hmHandleData);
4423
4424	return (lpResult); /* deliver return code */
4425	}
4426
4427	/*****************************************************************************
4428	* Name : HMGetNamedPipeHandleState
4429	* Purpose :
4430	* Parameters:
4431	* Variables :
4432	* Result :
4433	* Remark :
4434	* Status :
4435	*
4436	* Author : Przemyslaw Dobrowolski
4437	*****************************************************************************/
4438	BOOL HMGetNamedPipeHandleState(HANDLE hPipe,
4439	LPDWORD lpState,
4440	LPDWORD lpCurInstances,
4441	LPDWORD lpMaxCollectionCount,
4442	LPDWORD lpCollectDataTimeout,
4443	LPTSTR lpUserName,
4444	DWORD nMaxUserNameSize)
4445	{
4446	int iIndex; /* index into the handle table */
4447	BOOL lpResult; /* result from the device handler's API */
4448	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4449
4450	SetLastError(ERROR_SUCCESS);
4451	/* validate handle */
4452	iIndex = _HMHandleQuery(hPipe); /* get the index */
4453	if (-1 == iIndex) /* error ? */
4454	{
4455	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4456	return FALSE; /* signal failure */
4457	}
4458
4459	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4460	lpResult = pHMHandle->pDeviceHandler->GetNamedPipeHandleState(&TabWin32Handles[iIndex].hmHandleData,
4461	lpState,
4462	lpCurInstances,
4463	lpMaxCollectionCount,
4464	lpCollectDataTimeout,
4465	lpUserName,
4466	nMaxUserNameSize);
4467
4468
4469	return (lpResult); /* deliver return code */
4470	}
4471
4472	/*****************************************************************************
4473	* Name : HMGetNamedPipeInfo
4474	* Purpose :
4475	* Parameters:
4476	* Variables :
4477	* Result :
4478	* Remark :
4479	* Status :
4480	*
4481	* Author : Przemyslaw Dobrowolski
4482	*****************************************************************************/
4483	BOOL HMGetNamedPipeInfo(HANDLE hPipe,
4484	LPDWORD lpFlags,
4485	LPDWORD lpOutBufferSize,
4486	LPDWORD lpInBufferSize,
4487	LPDWORD lpMaxInstances)
4488	{
4489	int iIndex; /* index into the handle table */
4490	BOOL lpResult; /* result from the device handler's API */
4491	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4492
4493	SetLastError(ERROR_SUCCESS);
4494	/* validate handle */
4495	iIndex = _HMHandleQuery(hPipe); /* get the index */
4496	if (-1 == iIndex) /* error ? */
4497	{
4498	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4499	return FALSE; /* signal failure */
4500	}
4501
4502	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4503	lpResult = pHMHandle->pDeviceHandler->GetNamedPipeInfo(&TabWin32Handles[iIndex].hmHandleData,
4504	lpFlags,
4505	lpOutBufferSize,
4506	lpInBufferSize,
4507	lpMaxInstances);
4508
4509	return (lpResult); /* deliver return code */
4510	}
4511
4512	/*****************************************************************************
4513	* Name : HMTransactNamedPipe
4514	* Purpose :
4515	* Parameters:
4516	* Variables :
4517	* Result :
4518	* Remark :
4519	* Status :
4520	*
4521	* Author : Przemyslaw Dobrowolski
4522	*****************************************************************************/
4523	DWORD HMTransactNamedPipe(HANDLE hPipe,
4524	LPVOID lpvWriteBuf,
4525	DWORD cbWriteBuf,
4526	LPVOID lpvReadBuf,
4527	DWORD cbReadBuf,
4528	LPDWORD lpcbRead,
4529	LPOVERLAPPED lpo)
4530	{
4531	int iIndex; /* index into the handle table */
4532	DWORD lpResult; /* result from the device handler's API */
4533	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4534
4535	SetLastError(ERROR_SUCCESS);
4536	/* validate handle */
4537	iIndex = _HMHandleQuery(hPipe); /* get the index */
4538	if (-1 == iIndex) /* error ? */
4539	{
4540	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4541	return FALSE; /* signal failure */
4542	}
4543
4544	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4545	lpResult = pHMHandle->pDeviceHandler->TransactNamedPipe(&TabWin32Handles[iIndex].hmHandleData,
4546	lpvWriteBuf,
4547	cbWriteBuf,
4548	lpvReadBuf,
4549	cbReadBuf,
4550	lpcbRead,
4551	lpo);
4552
4553	return (lpResult); /* deliver return code */
4554	}
4555
4556	/*****************************************************************************
4557	* Name : HMSetNamedPipeHandleState
4558	* Purpose :
4559	* Parameters:
4560	* Variables :
4561	* Result :
4562	* Remark :
4563	* Status :
4564	*
4565	* Author : Przemyslaw Dobrowolski
4566	*****************************************************************************/
4567	BOOL HMSetNamedPipeHandleState(HANDLE hPipe,
4568	LPDWORD lpdwMode,
4569	LPDWORD lpcbMaxCollect,
4570	LPDWORD lpdwCollectDataTimeout)
4571	{
4572	int iIndex; /* index into the handle table */
4573	BOOL lpResult; /* result from the device handler's API */
4574	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4575
4576	SetLastError(ERROR_SUCCESS);
4577	/* validate handle */
4578	iIndex = _HMHandleQuery(hPipe); /* get the index */
4579	if (-1 == iIndex) /* error ? */
4580	{
4581	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4582	return FALSE; /* signal failure */
4583	}
4584
4585	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4586	lpResult = pHMHandle->pDeviceHandler->SetNamedPipeHandleState(&TabWin32Handles[iIndex].hmHandleData,
4587	lpdwMode,
4588	lpcbMaxCollect,
4589	lpdwCollectDataTimeout);
4590
4591	return (lpResult); /* deliver return code */
4592	}
4593
4594	/*****************************************************************************
4595	* Name : HMCreatePipe
4596	* Purpose :
4597	* Parameters:
4598	* Variables :
4599	* Result :
4600	* Remark :
4601	* Status : NOT TESTED!
4602	*
4603	* Author : Przemyslaw Dobrowolski
4604	*****************************************************************************/
4605	BOOL HMCreatePipe(PHANDLE phRead,
4606	PHANDLE phWrite,
4607	LPSECURITY_ATTRIBUTES lpsa,
4608	DWORD cbPipe)
4609	{
4610	int iIndex; /* index into the handle table */
4611	int iIndexNewRead; /* index into the handle table */
4612	int iIndexNewWrite; /* index into the handle table */
4613	HMDeviceHandler pDeviceHandler; / device handler for this handle */
4614	PHMHANDLEDATA pHMHandleData;
4615	HANDLE rc; /* API return code */
4616
4617	SetLastError(ERROR_SUCCESS);
4618
4619	pDeviceHandler = HMGlobals.pHMNamedPipe; /* device is predefined */
4620
4621	iIndexNewRead = _HMHandleGetFree(); /* get free handle */
4622	if (-1 == iIndexNewRead) /* oops, no free handles ! */
4623	{
4624	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
4625	return 0;
4626	}
4627
4628	iIndexNewWrite = _HMHandleGetFree(); /* get free handle */
4629	if (-1 == iIndexNewWrite) /* oops, no free handles ! */
4630	{
4631	HMHandleFree(iIndexNewRead);
4632	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
4633	return 0;
4634	}
4635
4636
4637	/* initialize the complete HMHANDLEDATA structure */
4638	pHMHandleData = &TabWin32Handles[iIndexNewRead].hmHandleData;
4639	pHMHandleData->dwAccess = 0;
4640	pHMHandleData->dwShare = 0;
4641	pHMHandleData->dwCreation = 0;
4642	pHMHandleData->dwFlags = 0;
4643	pHMHandleData->lpHandlerData = NULL;
4644
4645	/* we've got to mark the handle as occupied here, since another device */
4646	/* could be created within the device handler -> deadlock */
4647
4648	/* write appropriate entry into the handle table if open succeeded */
4649	TabWin32Handles[iIndexNewRead].hmHandleData.hHMHandle = iIndexNewRead;
4650	TabWin32Handles[iIndexNewRead].pDeviceHandler = pDeviceHandler;
4651
4652	/* initialize the complete HMHANDLEDATA structure */
4653	pHMHandleData = &TabWin32Handles[iIndexNewWrite].hmHandleData;
4654	pHMHandleData->dwAccess = 0;
4655	pHMHandleData->dwShare = 0;
4656	pHMHandleData->dwCreation = 0;
4657	pHMHandleData->dwFlags = 0;
4658	pHMHandleData->lpHandlerData = NULL;
4659
4660	/* we've got to mark the handle as occupied here, since another device */
4661	/* could be created within the device handler -> deadlock */
4662
4663	/* write appropriate entry into the handle table if open succeeded */
4664	TabWin32Handles[iIndexNewWrite].hmHandleData.hHMHandle = iIndexNewWrite;
4665	TabWin32Handles[iIndexNewWrite].pDeviceHandler = pDeviceHandler;
4666	/* call the device handler */
4667
4668	rc = pDeviceHandler->CreatePipe(&TabWin32Handles[iIndexNewRead].hmHandleData,
4669	&TabWin32Handles[iIndexNewWrite].hmHandleData,
4670	lpsa,
4671	cbPipe);
4672
4673	if (rc == 0) /* oops, creation failed within the device handler */
4674	{
4675	HMHandleFree(iIndexNewRead);
4676	HMHandleFree(iIndexNewWrite);
4677	return FALSE; /* signal error */
4678	}
4679
4680	*phRead = iIndexNewRead;
4681	*phWrite = iIndexNewWrite;
4682
4683	return TRUE;
4684	}
4685
4686	/*****************************************************************************
4687	* Name : HMCreateMailslotA
4688	* Purpose :
4689	* Parameters:
4690	* Variables :
4691	* Result :
4692	* Remark :
4693	* Status :
4694	*
4695	* Author : SvL
4696	*****************************************************************************/
4697	HANDLE HMCreateMailslotA(LPCSTR lpName, DWORD nMaxMessageSize,
4698	DWORD lReadTimeout,
4699	LPSECURITY_ATTRIBUTES lpSecurityAttributes)
4700	{
4701	int iIndex; /* index into the handle table */
4702	int iIndexNew; /* index into the handle table */
4703	HMMailslotClass pDeviceHandler; / device handler for this handle */
4704	PHMHANDLEDATA pHMHandleData;
4705	BOOL rc; /* API return code */
4706
4707	SetLastError(ERROR_SUCCESS);
4708
4709	pDeviceHandler = (HMMailslotClass )HMGlobals.pHMMailslot; / device is predefined */
4710
4711	iIndexNew = _HMHandleGetFree(); /* get free handle */
4712	if (-1 == iIndexNew) /* oops, no free handles ! */
4713	{
4714	SetLastError(ERROR_NOT_ENOUGH_MEMORY); /* use this as error message */
4715	return 0;
4716	}
4717
4718	/* initialize the complete HMHANDLEDATA structure */
4719	pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
4720	pHMHandleData->dwAccess = 0;
4721	pHMHandleData->dwShare = 0;
4722	pHMHandleData->dwCreation = 0;
4723	pHMHandleData->dwFlags = 0;
4724	pHMHandleData->lpHandlerData = NULL;
4725
4726	/* we've got to mark the handle as occupied here, since another device */
4727	/* could be created within the device handler -> deadlock */
4728
4729	/* write appropriate entry into the handle table if open succeeded */
4730	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
4731	TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
4732
4733	/* call the device handler */
4734
4735	rc = pDeviceHandler->CreateMailslotA(&TabWin32Handles[iIndexNew].hmHandleData,
4736	lpName, nMaxMessageSize,
4737	lReadTimeout, lpSecurityAttributes);
4738
4739	if (rc == FALSE) /* oops, creation failed within the device handler */
4740	{
4741	TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
4742	return 0; /* signal error */
4743	}
4744
4745	return iIndexNew;
4746	}
4747	/*****************************************************************************
4748	* Name : HMGetMailslotInfo
4749	* Purpose :
4750	* Parameters:
4751	* Variables :
4752	* Result :
4753	* Remark :
4754	* Status :
4755	*
4756	* Author : SvL
4757	*****************************************************************************/
4758	BOOL HMGetMailslotInfo(HANDLE hMailslot,
4759	LPDWORD lpMaxMessageSize,
4760	LPDWORD lpNextSize,
4761	LPDWORD lpMessageCount,
4762	LPDWORD lpReadTimeout)
4763	{
4764	int iIndex; /* index into the handle table */
4765	BOOL lpResult; /* result from the device handler's API */
4766	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4767
4768	SetLastError(ERROR_SUCCESS);
4769	/* validate handle */
4770	iIndex = _HMHandleQuery(hMailslot); /* get the index */
4771	if (-1 == iIndex) /* error ? */
4772	{
4773	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4774	return FALSE; /* signal failure */
4775	}
4776
4777	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4778	lpResult = pHMHandle->pDeviceHandler->GetMailslotInfo(&TabWin32Handles[iIndex].hmHandleData,
4779	lpMaxMessageSize,
4780	lpNextSize,
4781	lpMessageCount,
4782	lpReadTimeout);
4783	return (lpResult); /* deliver return code */
4784	}
4785	/*****************************************************************************
4786	* Name : HMSetMailslotInfo
4787	* Purpose :
4788	* Parameters:
4789	* Variables :
4790	* Result :
4791	* Remark :
4792	* Status :
4793	*
4794	* Author : SvL
4795	*****************************************************************************/
4796	BOOL HMSetMailslotInfo(HANDLE hMailslot,
4797	DWORD dwReadTimeout)
4798	{
4799	int iIndex; /* index into the handle table */
4800	BOOL lpResult; /* result from the device handler's API */
4801	PHMHANDLE pHMHandle; /* pointer to the handle structure in the table */
4802
4803	SetLastError(ERROR_SUCCESS);
4804	/* validate handle */
4805	iIndex = _HMHandleQuery(hMailslot); /* get the index */
4806	if (-1 == iIndex) /* error ? */
4807	{
4808	SetLastError(ERROR_INVALID_HANDLE); /* set win32 error information */
4809	return FALSE; /* signal failure */
4810	}
4811
4812	pHMHandle = &TabWin32Handles[iIndex]; /* call device handler */
4813	lpResult = pHMHandle->pDeviceHandler->SetMailslotInfo(&TabWin32Handles[iIndex].hmHandleData,
4814	dwReadTimeout);
4815
4816	return (lpResult); /* deliver return code */
4817	}

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

Download in other formats: