source: trunk/src/kernel32/hmdevice.cpp@ 690

Last change on this file since 690 was 690, checked in by sandervl, 26 years ago

handle manager changes for DuplicateHandle + memory mapped file changes/bugfixes
File size: 35.5 KB
Line 
1/* $Id: hmdevice.cpp,v 1.7 1999-08-25 14:27:05 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 * 1998/02/11 PH Patrick Haller (haller@zebra.fh-weingarten.de)
7 */
8
9
10/*****************************************************************************
11 * Remark *
12 *****************************************************************************
13 */
14
15
16/*****************************************************************************
17 * Includes *
18 *****************************************************************************/
19
20#include <os2win.h>
21#include "HandleManager.h"
22#include "HMDevice.h"
23
24
25/*****************************************************************************
26 * Defines *
27 *****************************************************************************/
28
29
30/*****************************************************************************
31 * Structures *
32 *****************************************************************************/
33
34
35/*****************************************************************************
36 * This pseudo-device logs all device requests to the logfile and returns *
37 * ERROR_INVALID_FUNCTION to virtually all requests -> debugging *
38 *****************************************************************************/
39class HMDeviceDebugClass : public HMDeviceHandler
40{
41 public:
42 HMDeviceDebugClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
43};
44
45
46/*****************************************************************************
47 * Name : HMDeviceHandler::HMDeviceHandler
48 * Purpose : default constructor for a device handler object
49 * Parameters: LPCSTR lpDeviceName
50 * Variables :
51 * Result :
52 * Remark : this is only to identify the device for debugging purposes
53 * Status :
54 *
55 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
56 *****************************************************************************/
57
58HMDeviceHandler::HMDeviceHandler(LPCSTR lpDeviceName)
59{
60 /* only a reference on the device name */
61 HMDeviceHandler::lpHMDeviceName = lpDeviceName;
62}
63
64
65/*****************************************************************************
66 * Name : HMDeviceHandler::_DeviceReuqest
67 * Purpose : entry method for special request functions
68 * Parameters: ULONG ulRequestCode
69 * various parameters as required
70 * Variables :
71 * Result :
72 * Remark : the standard behaviour is to return an error code for non-
73 * existant request codes
74 * Status :
75 *
76 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
77 *****************************************************************************/
78DWORD HMDeviceHandler::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
79 ULONG ulRequestCode,
80 ULONG arg1,
81 ULONG arg2,
82 ULONG arg3,
83 ULONG arg4)
84{
85 dprintf(("KERNEL32:HandleManager::_DeviceRequest %s(%08x,%08x) - stub?\n",
86 lpHMDeviceName,
87 pHMHandleData,
88 ulRequestCode));
89
90 return(ERROR_INVALID_FUNCTION);
91}
92
93
94/*****************************************************************************
95 * Name : HMDeviceHandler::DuplicateHandle
96 * Purpose : dummy version
97 * Parameters:
98 * various parameters as required
99 * Variables :
100 * Result :
101 * Remark : the standard behaviour is to return an error code for non-
102 * existant request codes
103 * Status :
104 *
105 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
106 *****************************************************************************/
107BOOL HMDeviceHandler::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
108 PHMHANDLEDATA pHMSrcHandle,
109 HANDLE destprocess,
110 PHANDLE desthandle,
111 DWORD fdwAccess,
112 BOOL fInherit,
113 DWORD fdwOptions)
114{
115 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",
116 lpHMDeviceName,
117 pHMHandleData,
118 srcprocess, pHMSrcHandle, destprocess, desthandle));
119
120 return(ERROR_INVALID_FUNCTION);
121}
122
123/*****************************************************************************
124 * Name : DWORD HMDeviceHandler::CreateFile
125 * Purpose : this is called from the handle manager if a CreateFile() is
126 * performed on a handle
127 * Parameters: LPCSTR lpFileName name of the file / device
128 * PHMHANDLEDATA pHMHandleData data of the NEW handle
129 * PVOID lpSecurityAttributes ignored
130 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
131 * Variables :
132 * Result :
133 * Remark :
134 * Status : NO_ERROR - API succeeded
135 * other - what is to be set in SetLastError
136 *
137 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
138 *****************************************************************************/
139
140DWORD HMDeviceHandler::CreateFile (LPCSTR lpFileName,
141 PHMHANDLEDATA pHMHandleData,
142 PVOID lpSecurityAttributes,
143 PHMHANDLEDATA pHMHandleDataTemplate)
144{
145 dprintf(("KERNEL32:HandleManager::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
146 lpHMDeviceName,
147 lpFileName,
148 pHMHandleData,
149 lpSecurityAttributes,
150 pHMHandleDataTemplate));
151
152 return(ERROR_INVALID_FUNCTION);
153}
154
155
156/*****************************************************************************
157 * Name : DWORD HMDeviceHandler::CloseHandle
158 * Purpose : close the handle
159 * Parameters: PHMHANDLEDATA pHMHandleData
160 * Variables :
161 * Result : API returncode
162 * Remark :
163 * Status :
164 *
165 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
166 *****************************************************************************/
167
168DWORD HMDeviceHandler::CloseHandle(PHMHANDLEDATA pHMHandleData)
169{
170 dprintf(("KERNEL32:HandleManager::CloseHandle %s(%08x) - stub?\n",
171 lpHMDeviceName,
172 pHMHandleData));
173
174 return(ERROR_INVALID_FUNCTION);
175}
176
177
178/*****************************************************************************
179 * Name : DWORD HMDeviceHandler::ReadFile
180 * Purpose : read data from handle / device
181 * Parameters: PHMHANDLEDATA pHMHandleData,
182 * LPCVOID lpBuffer,
183 * DWORD nNumberOfBytesToRead,
184 * LPDWORD lpNumberOfBytesRead,
185 * LPOVERLAPPED lpOverlapped
186 * Variables :
187 * Result : API returncode
188 * Remark :
189 * Status :
190 *
191 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
192 *****************************************************************************/
193
194DWORD HMDeviceHandler::ReadFile(PHMHANDLEDATA pHMHandleData,
195 LPCVOID lpBuffer,
196 DWORD nNumberOfBytesToRead,
197 LPDWORD lpNumberOfBytesRead,
198 LPOVERLAPPED lpOverlapped)
199{
200 dprintf(("KERNEL32:HandleManager::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
201 lpHMDeviceName,
202 pHMHandleData,
203 lpBuffer,
204 nNumberOfBytesToRead,
205 lpNumberOfBytesRead,
206 lpOverlapped));
207
208 return(ERROR_INVALID_FUNCTION);
209}
210
211
212/*****************************************************************************
213 * Name : DWORD HMDeviceHandler::WriteFile
214 * Purpose : write data to handle / device
215 * Parameters: PHMHANDLEDATA pHMHandleData,
216 * LPCVOID lpBuffer,
217 * DWORD nNumberOfBytesToWrite,
218 * LPDWORD lpNumberOfBytesWritten,
219 * LPOVERLAPPED lpOverlapped
220 * Variables :
221 * Result : API returncode
222 * Remark :
223 * Status :
224 *
225 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
226 *****************************************************************************/
227
228DWORD HMDeviceHandler::WriteFile(PHMHANDLEDATA pHMHandleData,
229 LPCVOID lpBuffer,
230 DWORD nNumberOfBytesToWrite,
231 LPDWORD lpNumberOfBytesWritten,
232 LPOVERLAPPED lpOverlapped)
233{
234 dprintf(("KERNEL32:HandleManager::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
235 lpHMDeviceName,
236 pHMHandleData,
237 lpBuffer,
238 nNumberOfBytesToWrite,
239 lpNumberOfBytesWritten,
240 lpOverlapped));
241
242 return(ERROR_INVALID_FUNCTION);
243}
244
245
246/*****************************************************************************
247 * Name : DWORD HMDeviceHandler::GetFileType
248 * Purpose : determine the handle type
249 * Parameters: PHMHANDLEDATA pHMHandleData
250 * Variables :
251 * Result : API returncode
252 * Remark :
253 * Status :
254 *
255 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
256 *****************************************************************************/
257
258DWORD HMDeviceHandler::GetFileType(PHMHANDLEDATA pHMHandleData)
259{
260 dprintf(("KERNEL32:HandleManager::GetFileType %s(%08x)\n",
261 lpHMDeviceName,
262 pHMHandleData));
263
264 return pHMHandleData->dwType;
265}
266
267
268/*****************************************************************************
269 * Name : DWORD HMDeviceHandler::GetFileInformationByHandle
270 * Purpose : determine the handle type
271 * Parameters: PHMHANDLEDATA pHMHandleData
272 * BY_HANDLE_FILE_INFORMATION* pHFI
273 * Variables :
274 * Result : API returncode
275 * Remark :
276 * Status :
277 *
278 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
279 *****************************************************************************/
280
281DWORD HMDeviceHandler::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
282 BY_HANDLE_FILE_INFORMATION* pHFI)
283{
284 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileInformationByHandle %s(%08xh,%08xh)\n",
285 lpHMDeviceName,
286 pHMHandleData,
287 pHFI));
288
289 return(ERROR_INVALID_FUNCTION);
290}
291
292
293/*****************************************************************************
294 * Name : BOOL HMDeviceHandler::SetEndOfFile
295 * Purpose : set end of file marker
296 * Parameters: PHMHANDLEDATA pHMHandleData
297 * Variables :
298 * Result : API returncode
299 * Remark :
300 * Status :
301 *
302 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
303 *****************************************************************************/
304
305BOOL HMDeviceHandler::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
306{
307 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetEndOfFile %s(%08xh)\n",
308 lpHMDeviceName,
309 pHMHandleData));
310
311 return(ERROR_INVALID_FUNCTION);
312}
313
314
315/*****************************************************************************
316 * Name : BOOL HMDeviceHandler::SetFileTime
317 * Purpose : set file time
318 * Parameters: PHMHANDLEDATA pHMHandleData
319 * PFILETIME pFT1
320 * PFILETIME pFT2
321 * PFILETIME pFT3
322 * Variables :
323 * Result : API returncode
324 * Remark :
325 * Status :
326 *
327 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
328 *****************************************************************************/
329
330BOOL HMDeviceHandler::SetFileTime(PHMHANDLEDATA pHMHandleData,
331 LPFILETIME pFT1,
332 LPFILETIME pFT2,
333 LPFILETIME pFT3)
334{
335 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
336 lpHMDeviceName,
337 pHMHandleData,
338 pFT1,
339 pFT2,
340 pFT3));
341
342 return(ERROR_INVALID_FUNCTION);
343}
344
345
346/*****************************************************************************
347 * Name : DWORD HMDeviceHandler::GetFileSize
348 * Purpose : set file time
349 * Parameters: PHMHANDLEDATA pHMHandleData
350 * PDWORD pSize
351 * Variables :
352 * Result : API returncode
353 * Remark :
354 * Status :
355 *
356 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
357 *****************************************************************************/
358
359DWORD HMDeviceHandler::GetFileSize(PHMHANDLEDATA pHMHandleData,
360 PDWORD pSize)
361{
362 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileSize %s(%08xh,%08xh)\n",
363 lpHMDeviceName,
364 pHMHandleData,
365 pSize));
366
367 return(ERROR_INVALID_FUNCTION);
368}
369
370
371/*****************************************************************************
372 * Name : DWORD HMDeviceHandler::SetFilePointer
373 * Purpose : set file pointer
374 * Parameters: PHMHANDLEDATA pHMHandleData
375 * LONG lDistanceToMove
376 * PLONG lpDistanceToMoveHigh
377 * DWORD dwMoveMethod
378 * Variables :
379 * Result : API returncode
380 * Remark :
381 * Status :
382 *
383 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
384 *****************************************************************************/
385
386DWORD HMDeviceHandler::SetFilePointer(PHMHANDLEDATA pHMHandleData,
387 LONG lDistanceToMove,
388 PLONG lpDistanceToMoveHigh,
389 DWORD dwMoveMethod)
390{
391 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
392 lpHMDeviceName,
393 pHMHandleData,
394 lDistanceToMove,
395 lpDistanceToMoveHigh,
396 dwMoveMethod));
397
398 return(ERROR_INVALID_FUNCTION);
399}
400
401
402/*****************************************************************************
403 * Name : DWORD HMDeviceHandler::LockFile
404 * Purpose : file locking
405 * Parameters: PHMHANDLEDATA pHMHandleData
406 * DWORD arg2
407 * DWORD arg3
408 * DWORD arg4
409 * DWORD arg5
410 * Variables :
411 * Result : API returncode
412 * Remark :
413 * Status :
414 *
415 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
416 *****************************************************************************/
417
418DWORD HMDeviceHandler::LockFile(PHMHANDLEDATA pHMHandleData,
419 DWORD arg2,
420 DWORD arg3,
421 DWORD arg4,
422 DWORD arg5)
423{
424 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
425 lpHMDeviceName,
426 pHMHandleData,
427 arg2,
428 arg3,
429 arg4,
430 arg5));
431
432 return(ERROR_INVALID_FUNCTION);
433}
434
435
436
437/*****************************************************************************
438 * Name : DWORD HMDeviceHandler::LockFileEx
439 * Purpose : file locking
440 * Parameters: PHMHANDLEDATA pHMHandleData
441 * DWORD dwFlags
442 * DWORD dwReserved
443 * DWORD nNumberOfBytesToLockLow
444 * DWORD nNumberOfBytesToLockHigh
445 * LPOVERLAPPED lpOverlapped
446 * Variables :
447 * Result : API returncode
448 * Remark :
449 * Status :
450 *
451 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
452 *****************************************************************************/
453
454DWORD HMDeviceHandler::LockFileEx(PHMHANDLEDATA pHMHandleData,
455 DWORD dwFlags,
456 DWORD dwReserved,
457 DWORD nNumberOfBytesToLockLow,
458 DWORD nNumberOfBytesToLockHigh,
459 LPOVERLAPPED lpOverlapped)
460{
461
462 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
463 lpHMDeviceName,
464 pHMHandleData,
465 dwFlags,
466 dwReserved,
467 nNumberOfBytesToLockLow,
468 nNumberOfBytesToLockHigh,
469 lpOverlapped));
470
471 return(ERROR_INVALID_FUNCTION);
472}
473
474
475/*****************************************************************************
476 * Name : DWORD HMDeviceHandler::OpenFile
477 * Purpose : this is called from the handle manager if a OpenFile() is
478 * performed on a handle
479 * Parameters: LPCSTR lpFileName name of the file / device
480 * PHMHANDLEDATA pHMHandleData data of the NEW handle
481 * PVOID lpSecurityAttributes ignored
482 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
483 * Variables :
484 * Result :
485 * Remark :
486 * Status : NO_ERROR - API succeeded
487 * other - what is to be set in SetLastError
488 *
489 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
490 *****************************************************************************/
491
492DWORD HMDeviceHandler::OpenFile (LPCSTR lpFileName,
493 PHMHANDLEDATA pHMHandleData,
494 OFSTRUCT *pOFStruct,
495 UINT arg3)
496{
497 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
498 lpHMDeviceName,
499 lpFileName,
500 pHMHandleData,
501 pOFStruct,
502 arg3));
503
504 return(ERROR_INVALID_FUNCTION);
505}
506
507
508/*****************************************************************************
509 * Name : DWORD HMDeviceHandler::UnlockFile
510 * Purpose : file locking
511 * Parameters: PHMHANDLEDATA pHMHandleData
512 * DWORD arg2
513 * DWORD arg3
514 * DWORD arg4
515 * DWORD arg5
516 * Variables :
517 * Result : API returncode
518 * Remark :
519 * Status :
520 *
521 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
522 *****************************************************************************/
523
524DWORD HMDeviceHandler::UnlockFile(PHMHANDLEDATA pHMHandleData,
525 DWORD arg2,
526 DWORD arg3,
527 DWORD arg4,
528 DWORD arg5)
529{
530 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
531 lpHMDeviceName,
532 pHMHandleData,
533 arg2,
534 arg3,
535 arg4,
536 arg5));
537
538 return(ERROR_INVALID_FUNCTION);
539}
540
541
542
543/*****************************************************************************
544 * Name : DWORD HMDeviceHandler::UnlockFileEx
545 * Purpose : file locking
546 * Parameters: PHMHANDLEDATA pHMHandleData
547 * DWORD dwFlags
548 * DWORD dwReserved
549 * DWORD nNumberOfBytesToLockLow
550 * DWORD nNumberOfBytesToLockHigh
551 * LPOVERLAPPED lpOverlapped
552 * Variables :
553 * Result : API returncode
554 * Remark :
555 * Status :
556 *
557 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
558 *****************************************************************************/
559
560DWORD HMDeviceHandler::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
561 DWORD dwFlags,
562 DWORD dwReserved,
563 DWORD nNumberOfBytesToLockLow,
564 DWORD nNumberOfBytesToLockHigh,
565 LPOVERLAPPED lpOverlapped)
566{
567 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
568 lpHMDeviceName,
569 pHMHandleData,
570 dwFlags,
571 dwReserved,
572 nNumberOfBytesToLockLow,
573 nNumberOfBytesToLockHigh,
574 lpOverlapped));
575
576 return(ERROR_INVALID_FUNCTION);
577}
578
579
580
581/*****************************************************************************
582 * Name : HMCreateSemaphore
583 * Purpose : router function for CreateSemaphore
584 * Parameters:
585 * Variables :
586 * Result :
587 * Remark :
588 * Status :
589 *
590 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
591 *****************************************************************************/
592
593DWORD HMDeviceHandler::CreateSemaphore(PHMHANDLEDATA pHMHandleData,
594 LPSECURITY_ATTRIBUTES lpsa,
595 LONG lInitialCount,
596 LONG lMaximumCount,
597 LPCTSTR lpszSemaphoreName)
598{
599 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateSemaphore(%08xh,%08xh,%08xh,%08xh,%s)\n",
600 pHMHandleData,
601 lpsa,
602 lInitialCount,
603 lMaximumCount,
604 lpszSemaphoreName));
605
606 return (ERROR_INVALID_FUNCTION);
607}
608
609
610/*****************************************************************************
611 * Name : HMOpenSemaphore
612 * Purpose : router function for OpenSemaphore
613 * Parameters:
614 * Variables :
615 * Result :
616 * Remark :
617 * Status :
618 *
619 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
620 *****************************************************************************/
621
622DWORD HMDeviceHandler::OpenSemaphore(PHMHANDLEDATA pHMHandleData,
623 BOOL fInheritHandle,
624 LPCTSTR lpszSemaphoreName)
625{
626 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenSemaphore(%08xh,%08xh,%s)\n",
627 pHMHandleData,
628 fInheritHandle,
629 lpszSemaphoreName));
630
631 return (ERROR_INVALID_FUNCTION);
632}
633
634
635/*****************************************************************************
636 * Name : HMReleaseSemaphore
637 * Purpose : router function for ReleaseSemaphore
638 * Parameters:
639 * Variables :
640 * Result :
641 * Remark :
642 * Status :
643 *
644 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
645 *****************************************************************************/
646
647BOOL HMDeviceHandler::ReleaseSemaphore(PHMHANDLEDATA pHMHandleData,
648 LONG cReleaseCount,
649 LPLONG lpPreviousCount)
650{
651 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseSemaphore(%08xh,%08xh,%08xh)\n",
652 pHMHandleData->hHMHandle,
653 cReleaseCount,
654 lpPreviousCount));
655
656 return (ERROR_INVALID_FUNCTION);
657}
658
659
660
661/*****************************************************************************
662 * Name : HMCreateMutex
663 * Purpose : router function for CreateMutex
664 * Parameters:
665 * Variables :
666 * Result :
667 * Remark :
668 * Status :
669 *
670 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
671 *****************************************************************************/
672
673DWORD HMDeviceHandler::CreateMutex(PHMHANDLEDATA pHMHandleData,
674 LPSECURITY_ATTRIBUTES lpsa,
675 BOOL fInitialOwner,
676 LPCTSTR lpszMutexName)
677{
678 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateMutex(%08xh,%08xh,%08xh,%s)\n",
679 pHMHandleData,
680 lpsa,
681 fInitialOwner,
682 lpszMutexName));
683
684 return (ERROR_INVALID_FUNCTION);
685}
686
687
688/*****************************************************************************
689 * Name : HMOpenMutex
690 * Purpose : router function for OpenMutex
691 * Parameters:
692 * Variables :
693 * Result :
694 * Remark :
695 * Status :
696 *
697 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
698 *****************************************************************************/
699
700DWORD HMDeviceHandler::OpenMutex(PHMHANDLEDATA pHMHandleData,
701 BOOL fInheritHandle,
702 LPCTSTR lpszMutexName)
703{
704 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenMutex(%08xh,%08xh,%s)\n",
705 pHMHandleData,
706 fInheritHandle,
707 lpszMutexName));
708
709 return (ERROR_INVALID_FUNCTION);
710}
711
712
713/*****************************************************************************
714 * Name : HMReleaseMutex
715 * Purpose : router function for ReleaseMutex
716 * Parameters:
717 * Variables :
718 * Result :
719 * Remark :
720 * Status :
721 *
722 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
723 *****************************************************************************/
724
725BOOL HMDeviceHandler::ReleaseMutex(PHMHANDLEDATA pHMHandleData)
726{
727 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseMutex(%08xh)\n",
728 pHMHandleData->hHMHandle));
729
730 return (ERROR_INVALID_FUNCTION);
731}
732
733
734/*****************************************************************************
735 * Name : HMCreateEvent
736 * Purpose : router function for CreateEvent
737 * Parameters:
738 * Variables :
739 * Result :
740 * Remark :
741 * Status :
742 *
743 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
744 *****************************************************************************/
745
746DWORD HMDeviceHandler::CreateEvent(PHMHANDLEDATA pHMHandleData,
747 LPSECURITY_ATTRIBUTES lpsa,
748 BOOL fManualReset,
749 BOOL fInitialState,
750 LPCTSTR lpszEventName)
751{
752 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateEvent(%08xh,%08xh,%08xh,%08xh,%s)\n",
753 pHMHandleData,
754 lpsa,
755 fManualReset,
756 fInitialState,
757 lpszEventName));
758
759 return (ERROR_INVALID_FUNCTION);
760}
761
762
763/*****************************************************************************
764 * Name : HMOpenEvent
765 * Purpose : router function for OpenEvent
766 * Parameters:
767 * Variables :
768 * Result :
769 * Remark :
770 * Status :
771 *
772 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
773 *****************************************************************************/
774
775DWORD HMDeviceHandler::OpenEvent(PHMHANDLEDATA pHMHandleData,
776 BOOL fInheritHandle,
777 LPCTSTR lpszEventName)
778{
779 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenEvent(%08xh,%08xh,%s)\n",
780 pHMHandleData,
781 fInheritHandle,
782 lpszEventName));
783
784 return (ERROR_INVALID_FUNCTION);
785}
786
787
788/*****************************************************************************
789 * Name : HMSetEvent
790 * Purpose : router function for SetEvent
791 * Parameters:
792 * Variables :
793 * Result :
794 * Remark :
795 * Status :
796 *
797 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
798 *****************************************************************************/
799
800BOOL HMDeviceHandler::SetEvent(PHMHANDLEDATA pHMHandleData)
801{
802 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetEvent(%08xh)\n",
803 pHMHandleData->hHMHandle));
804
805 return (ERROR_INVALID_FUNCTION);
806}
807
808
809/*****************************************************************************
810 * Name : HMPulseEvent
811 * Purpose : router function for PulseEvent
812 * Parameters:
813 * Variables :
814 * Result :
815 * Remark :
816 * Status :
817 *
818 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
819 *****************************************************************************/
820
821BOOL HMDeviceHandler::PulseEvent(PHMHANDLEDATA pHMHandleData)
822{
823 dprintf(("KERNEL32: HandleManager::DeviceHandler::PulseEvent(%08xh)\n",
824 pHMHandleData->hHMHandle));
825
826 return (ERROR_INVALID_FUNCTION);
827}
828
829
830/*****************************************************************************
831 * Name : HMResetEvent
832 * Purpose : router function for ResetEvent
833 * Parameters:
834 * Variables :
835 * Result :
836 * Remark :
837 * Status :
838 *
839 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
840 *****************************************************************************/
841
842BOOL HMDeviceHandler::ResetEvent(PHMHANDLEDATA pHMHandleData)
843{
844 dprintf(("KERNEL32: HandleManager::DeviceHandler::ResetEvent(%08xh)\n",
845 pHMHandleData->hHMHandle));
846
847 return (ERROR_INVALID_FUNCTION);
848}
849
850
851
852/*****************************************************************************
853 * Name : DWORD HMDeviceHandler::WaitForSingleObject
854 * Purpose : object synchronization
855 * Parameters: PHMHANDLEDATA pHMHandleData
856 * DWORD dwTimeout
857 * Variables :
858 * Result : API returncode
859 * Remark :
860 * Status :
861 *
862 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
863 *****************************************************************************/
864
865DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
866 DWORD dwTimeout)
867{
868 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObject(%08xh,%08h)\n",
869 pHMHandleData->hHMHandle,
870 dwTimeout));
871
872 return(ERROR_INVALID_FUNCTION);
873}
874
875
876/*****************************************************************************
877 * Name : DWORD HMDeviceHandler::WaitForSingleObjectEx
878 * Purpose : object synchronization
879 * Parameters: PHMHANDLEDATA pHMHandleData
880 * DWORD dwTimeout
881 * BOOL fAlertable
882 * Variables :
883 * Result : API returncode
884 * Remark :
885 * Status :
886 *
887 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
888 *****************************************************************************/
889
890DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
891 DWORD dwTimeout,
892 BOOL fAlertable)
893{
894 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
895 pHMHandleData->hHMHandle,
896 dwTimeout,
897 fAlertable));
898
899 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
900 return(ERROR_INVALID_FUNCTION);
901}
902
903
904/*****************************************************************************
905 * Name : DWORD HMDeviceHandler::FlushFileBuffers
906 * Purpose : flush the buffers of a file
907 * Parameters: PHMHANDLEDATA pHMHandleData
908 * Variables :
909 * Result : API returncode
910 * Remark :
911 * Status :
912 *
913 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
914 *****************************************************************************/
915
916BOOL HMDeviceHandler::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
917{
918 dprintf(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
919 pHMHandleData->hHMHandle));
920
921 return(ERROR_INVALID_FUNCTION);
922}
923
924
925/*****************************************************************************
926 * Name : DWORD HMDeviceHandler::GetOverlappedResult
927 * Purpose : asynchronus I/O
928 * Parameters: PHMHANDLEDATA pHMHandleData
929 * LPOVERLAPPED arg2
930 * LPDWORD arg3
931 * BOOL arg4
932 * Variables :
933 * Result : API returncode
934 * Remark :
935 * Status :
936 *
937 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
938 *****************************************************************************/
939
940BOOL HMDeviceHandler::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
941 LPOVERLAPPED arg2,
942 LPDWORD arg3,
943 BOOL arg4)
944{
945 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
946 pHMHandleData->hHMHandle,
947 arg2,
948 arg3,
949 arg4));
950
951 return(ERROR_INVALID_FUNCTION);
952}
953
954/*****************************************************************************
955 * Name : DWORD HMDeviceHandler::CreateFileMapping
956 * Purpose : create memory mapped file
957 * Parameters: PHMHANDLEDATA pHMHandleData
958 * LPSECURITY_ATTRIBUTES lpFileMappingAttributes
959 * DWORD flProtect
960 * DWORD dwMaximumSizeHigh
961 * DWORD dwMaximumSizeLow
962 * LPCTSTR lpName
963 * Variables :
964 * Result : API returncode
965 * Remark :
966 * Status :
967 *
968 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
969 *****************************************************************************/
970
971DWORD HMDeviceHandler::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
972 HANDLE hFile,
973 LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
974 DWORD flProtect,
975 DWORD dwMaximumSizeHigh,
976 DWORD dwMaximumSizeLow,
977 LPCTSTR lpName)
978{
979 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
980 pHMHandleData->hHMHandle,
981 hFile,
982 lpFileMappingAttributes,
983 flProtect,
984 dwMaximumSizeHigh,
985 dwMaximumSizeLow,
986 lpName));
987
988 return(ERROR_INVALID_FUNCTION);
989}
990
991
992/*****************************************************************************
993 * Name : DWORD HMDeviceHandler::OpenFileMapping
994 * Purpose : open memory mapped file
995 * Parameters: PHMHANDLEDATA pHMHandleData
996 * LPOVERLAPPED arg2
997 * LPDWORD arg3
998 * BOOL arg4
999 * Variables :
1000 * Result : API returncode
1001 * Remark :
1002 * Status :
1003 *
1004 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1005 *****************************************************************************/
1006
1007DWORD HMDeviceHandler::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
1008 DWORD fdwAccess,
1009 BOOL fInherit,
1010 LPCTSTR lpName)
1011{
1012 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
1013 pHMHandleData->hHMHandle,
1014 fdwAccess,
1015 fInherit,
1016 lpName));
1017
1018 return(ERROR_INVALID_FUNCTION);
1019}
1020
1021/*****************************************************************************
1022 * Name : DWORD HMDeviceHandler::MapViewOfFile
1023 * Purpose : map memory mapped file
1024 * Parameters: PHMHANDLEDATA pHMHandleData
1025 * DWORD dwDesiredAccess,
1026 * DWORD dwFileOffsetHigh,
1027 * DWORD dwFileOffsetLow,
1028 * DWORD dwNumberOfBytesToMap
1029 * Variables :
1030 * Result : address to memory mapped region
1031 * Remark :
1032 * Status :
1033 *
1034 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1035 *****************************************************************************/
1036
1037LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
1038 DWORD dwDesiredAccess,
1039 DWORD dwFileOffsetHigh,
1040 DWORD dwFileOffsetLow,
1041 DWORD dwNumberOfBytesToMap,
1042 LPVOID lpBaseAddress)
1043{
1044 dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1045 pHMHandleData->hHMHandle,
1046 dwDesiredAccess,
1047 dwFileOffsetHigh,
1048 dwFileOffsetLow,
1049 dwNumberOfBytesToMap, lpBaseAddress));
1050
1051 return(NULL);
1052}
Note: See TracBrowser for help on using the repository browser.