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

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

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