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

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

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