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

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

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