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

Last change on this file since 278 was 278, checked in by phaller, 26 years ago

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