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

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

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