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

Last change on this file since 3588 was 3588, checked in by sandervl, 25 years ago

GetFileTime bugfix + FindResource(Ex)A/W changes + setup thread security objects during creation
File size: 45.7 KB
Line 
1/* $Id: hmdevice.cpp,v 1.19 2000-05-22 19:07:54 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 * Name : BOOL HMDeviceHandler::GetFileTime
357 * Purpose : get file time
358 * Parameters: PHMHANDLEDATA pHMHandleData
359 * PFILETIME pFT1
360 * PFILETIME pFT2
361 * PFILETIME pFT3
362 * Variables :
363 * Result : API returncode
364 * Remark :
365 * Status :
366 *
367 * Author : SvL
368 *****************************************************************************/
369
370BOOL HMDeviceHandler::GetFileTime(PHMHANDLEDATA pHMHandleData,
371 LPFILETIME pFT1,
372 LPFILETIME pFT2,
373 LPFILETIME pFT3)
374{
375 DebugInt3();
376 return(ERROR_INVALID_FUNCTION);
377}
378
379
380/*****************************************************************************
381 * Name : DWORD HMDeviceHandler::GetFileSize
382 * Purpose : set file time
383 * Parameters: PHMHANDLEDATA pHMHandleData
384 * PDWORD pSize
385 * Variables :
386 * Result : API returncode
387 * Remark :
388 * Status :
389 *
390 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
391 *****************************************************************************/
392
393DWORD HMDeviceHandler::GetFileSize(PHMHANDLEDATA pHMHandleData,
394 PDWORD pSize)
395{
396 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileSize %s(%08xh,%08xh)\n",
397 lpHMDeviceName,
398 pHMHandleData,
399 pSize));
400
401 return(ERROR_INVALID_FUNCTION);
402}
403
404
405/*****************************************************************************
406 * Name : DWORD HMDeviceHandler::SetFilePointer
407 * Purpose : set file pointer
408 * Parameters: PHMHANDLEDATA pHMHandleData
409 * LONG lDistanceToMove
410 * PLONG lpDistanceToMoveHigh
411 * DWORD dwMoveMethod
412 * Variables :
413 * Result : API returncode
414 * Remark :
415 * Status :
416 *
417 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
418 *****************************************************************************/
419
420DWORD HMDeviceHandler::SetFilePointer(PHMHANDLEDATA pHMHandleData,
421 LONG lDistanceToMove,
422 PLONG lpDistanceToMoveHigh,
423 DWORD dwMoveMethod)
424{
425 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
426 lpHMDeviceName,
427 pHMHandleData,
428 lDistanceToMove,
429 lpDistanceToMoveHigh,
430 dwMoveMethod));
431
432 return(ERROR_INVALID_FUNCTION);
433}
434
435
436/*****************************************************************************
437 * Name : DWORD HMDeviceHandler::LockFile
438 * Purpose : file locking
439 * Parameters: PHMHANDLEDATA pHMHandleData
440 * DWORD arg2
441 * DWORD arg3
442 * DWORD arg4
443 * DWORD arg5
444 * Variables :
445 * Result : API returncode
446 * Remark :
447 * Status :
448 *
449 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
450 *****************************************************************************/
451
452DWORD HMDeviceHandler::LockFile(PHMHANDLEDATA pHMHandleData,
453 DWORD arg2,
454 DWORD arg3,
455 DWORD arg4,
456 DWORD arg5)
457{
458 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
459 lpHMDeviceName,
460 pHMHandleData,
461 arg2,
462 arg3,
463 arg4,
464 arg5));
465
466 return(ERROR_INVALID_FUNCTION);
467}
468
469
470
471/*****************************************************************************
472 * Name : DWORD HMDeviceHandler::LockFileEx
473 * Purpose : file locking
474 * Parameters: PHMHANDLEDATA pHMHandleData
475 * DWORD dwFlags
476 * DWORD dwReserved
477 * DWORD nNumberOfBytesToLockLow
478 * DWORD nNumberOfBytesToLockHigh
479 * LPOVERLAPPED lpOverlapped
480 * Variables :
481 * Result : API returncode
482 * Remark :
483 * Status :
484 *
485 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
486 *****************************************************************************/
487
488DWORD HMDeviceHandler::LockFileEx(PHMHANDLEDATA pHMHandleData,
489 DWORD dwFlags,
490 DWORD dwReserved,
491 DWORD nNumberOfBytesToLockLow,
492 DWORD nNumberOfBytesToLockHigh,
493 LPOVERLAPPED lpOverlapped)
494{
495
496 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
497 lpHMDeviceName,
498 pHMHandleData,
499 dwFlags,
500 dwReserved,
501 nNumberOfBytesToLockLow,
502 nNumberOfBytesToLockHigh,
503 lpOverlapped));
504
505 return(ERROR_INVALID_FUNCTION);
506}
507
508
509/*****************************************************************************
510 * Name : DWORD HMDeviceHandler::OpenFile
511 * Purpose : this is called from the handle manager if a OpenFile() is
512 * performed on a handle
513 * Parameters: LPCSTR lpFileName name of the file / device
514 * PHMHANDLEDATA pHMHandleData data of the NEW handle
515 * PVOID lpSecurityAttributes ignored
516 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
517 * Variables :
518 * Result :
519 * Remark :
520 * Status : NO_ERROR - API succeeded
521 * other - what is to be set in SetLastError
522 *
523 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
524 *****************************************************************************/
525
526DWORD HMDeviceHandler::OpenFile (LPCSTR lpFileName,
527 PHMHANDLEDATA pHMHandleData,
528 OFSTRUCT *pOFStruct,
529 UINT arg3)
530{
531 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
532 lpHMDeviceName,
533 lpFileName,
534 pHMHandleData,
535 pOFStruct,
536 arg3));
537
538 return(ERROR_INVALID_FUNCTION);
539}
540
541
542/*****************************************************************************
543 * Name : DWORD HMDeviceHandler::UnlockFile
544 * Purpose : file locking
545 * Parameters: PHMHANDLEDATA pHMHandleData
546 * DWORD arg2
547 * DWORD arg3
548 * DWORD arg4
549 * DWORD arg5
550 * Variables :
551 * Result : API returncode
552 * Remark :
553 * Status :
554 *
555 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
556 *****************************************************************************/
557
558DWORD HMDeviceHandler::UnlockFile(PHMHANDLEDATA pHMHandleData,
559 DWORD arg2,
560 DWORD arg3,
561 DWORD arg4,
562 DWORD arg5)
563{
564 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
565 lpHMDeviceName,
566 pHMHandleData,
567 arg2,
568 arg3,
569 arg4,
570 arg5));
571
572 return(ERROR_INVALID_FUNCTION);
573}
574
575
576
577/*****************************************************************************
578 * Name : DWORD HMDeviceHandler::UnlockFileEx
579 * Purpose : file locking
580 * Parameters: PHMHANDLEDATA pHMHandleData
581 * DWORD dwFlags
582 * DWORD dwReserved
583 * DWORD nNumberOfBytesToLockLow
584 * DWORD nNumberOfBytesToLockHigh
585 * LPOVERLAPPED lpOverlapped
586 * Variables :
587 * Result : API returncode
588 * Remark :
589 * Status :
590 *
591 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
592 *****************************************************************************/
593
594DWORD HMDeviceHandler::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
595 DWORD dwFlags,
596 DWORD dwReserved,
597 DWORD nNumberOfBytesToLockLow,
598 DWORD nNumberOfBytesToLockHigh,
599 LPOVERLAPPED lpOverlapped)
600{
601 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
602 lpHMDeviceName,
603 pHMHandleData,
604 dwFlags,
605 dwReserved,
606 nNumberOfBytesToLockLow,
607 nNumberOfBytesToLockHigh,
608 lpOverlapped));
609
610 return(ERROR_INVALID_FUNCTION);
611}
612
613
614
615/*****************************************************************************
616 * Name : HMCreateSemaphore
617 * Purpose : router function for CreateSemaphore
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::CreateSemaphore(PHMHANDLEDATA pHMHandleData,
628 LPSECURITY_ATTRIBUTES lpsa,
629 LONG lInitialCount,
630 LONG lMaximumCount,
631 LPCTSTR lpszSemaphoreName)
632{
633 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateSemaphore(%08xh,%08xh,%08xh,%08xh,%s)\n",
634 pHMHandleData,
635 lpsa,
636 lInitialCount,
637 lMaximumCount,
638 lpszSemaphoreName));
639
640 return (ERROR_INVALID_FUNCTION);
641}
642
643
644/*****************************************************************************
645 * Name : HMOpenSemaphore
646 * Purpose : router function for OpenSemaphore
647 * Parameters:
648 * Variables :
649 * Result :
650 * Remark :
651 * Status :
652 *
653 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
654 *****************************************************************************/
655
656DWORD HMDeviceHandler::OpenSemaphore(PHMHANDLEDATA pHMHandleData,
657 BOOL fInheritHandle,
658 LPCTSTR lpszSemaphoreName)
659{
660 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenSemaphore(%08xh,%08xh,%s)\n",
661 pHMHandleData,
662 fInheritHandle,
663 lpszSemaphoreName));
664
665 return (ERROR_INVALID_FUNCTION);
666}
667
668
669/*****************************************************************************
670 * Name : HMReleaseSemaphore
671 * Purpose : router function for ReleaseSemaphore
672 * Parameters:
673 * Variables :
674 * Result :
675 * Remark :
676 * Status :
677 *
678 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
679 *****************************************************************************/
680
681BOOL HMDeviceHandler::ReleaseSemaphore(PHMHANDLEDATA pHMHandleData,
682 LONG cReleaseCount,
683 LPLONG lpPreviousCount)
684{
685 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseSemaphore(%08xh,%08xh,%08xh)\n",
686 pHMHandleData->hHMHandle,
687 cReleaseCount,
688 lpPreviousCount));
689
690 return (ERROR_INVALID_FUNCTION);
691}
692
693
694
695/*****************************************************************************
696 * Name : HMCreateMutex
697 * Purpose : router function for CreateMutex
698 * Parameters:
699 * Variables :
700 * Result :
701 * Remark :
702 * Status :
703 *
704 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
705 *****************************************************************************/
706
707DWORD HMDeviceHandler::CreateMutex(PHMHANDLEDATA pHMHandleData,
708 LPSECURITY_ATTRIBUTES lpsa,
709 BOOL fInitialOwner,
710 LPCTSTR lpszMutexName)
711{
712 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateMutex(%08xh,%08xh,%08xh,%s)\n",
713 pHMHandleData,
714 lpsa,
715 fInitialOwner,
716 lpszMutexName));
717
718 return (ERROR_INVALID_FUNCTION);
719}
720
721
722/*****************************************************************************
723 * Name : HMOpenMutex
724 * Purpose : router function for OpenMutex
725 * Parameters:
726 * Variables :
727 * Result :
728 * Remark :
729 * Status :
730 *
731 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
732 *****************************************************************************/
733
734DWORD HMDeviceHandler::OpenMutex(PHMHANDLEDATA pHMHandleData,
735 BOOL fInheritHandle,
736 LPCTSTR lpszMutexName)
737{
738 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenMutex(%08xh,%08xh,%s)\n",
739 pHMHandleData,
740 fInheritHandle,
741 lpszMutexName));
742
743 return (ERROR_INVALID_FUNCTION);
744}
745
746
747/*****************************************************************************
748 * Name : HMReleaseMutex
749 * Purpose : router function for ReleaseMutex
750 * Parameters:
751 * Variables :
752 * Result :
753 * Remark :
754 * Status :
755 *
756 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
757 *****************************************************************************/
758
759BOOL HMDeviceHandler::ReleaseMutex(PHMHANDLEDATA pHMHandleData)
760{
761 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseMutex(%08xh)\n",
762 pHMHandleData->hHMHandle));
763
764 return (ERROR_INVALID_FUNCTION);
765}
766
767
768/*****************************************************************************
769 * Name : HMCreateEvent
770 * Purpose : router function for CreateEvent
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::CreateEvent(PHMHANDLEDATA pHMHandleData,
781 LPSECURITY_ATTRIBUTES lpsa,
782 BOOL fManualReset,
783 BOOL fInitialState,
784 LPCTSTR lpszEventName)
785{
786 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateEvent(%08xh,%08xh,%08xh,%08xh,%s)\n",
787 pHMHandleData,
788 lpsa,
789 fManualReset,
790 fInitialState,
791 lpszEventName));
792
793 return (ERROR_INVALID_FUNCTION);
794}
795
796
797/*****************************************************************************
798 * Name : HMOpenEvent
799 * Purpose : router function for OpenEvent
800 * Parameters:
801 * Variables :
802 * Result :
803 * Remark :
804 * Status :
805 *
806 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
807 *****************************************************************************/
808
809DWORD HMDeviceHandler::OpenEvent(PHMHANDLEDATA pHMHandleData,
810 BOOL fInheritHandle,
811 LPCTSTR lpszEventName)
812{
813 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenEvent(%08xh,%08xh,%s)\n",
814 pHMHandleData,
815 fInheritHandle,
816 lpszEventName));
817
818 return (ERROR_INVALID_FUNCTION);
819}
820
821
822/*****************************************************************************
823 * Name : HMSetEvent
824 * Purpose : router function for SetEvent
825 * Parameters:
826 * Variables :
827 * Result :
828 * Remark :
829 * Status :
830 *
831 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
832 *****************************************************************************/
833
834BOOL HMDeviceHandler::SetEvent(PHMHANDLEDATA pHMHandleData)
835{
836 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetEvent(%08xh)\n",
837 pHMHandleData->hHMHandle));
838
839 return (ERROR_INVALID_FUNCTION);
840}
841
842
843/*****************************************************************************
844 * Name : HMPulseEvent
845 * Purpose : router function for PulseEvent
846 * Parameters:
847 * Variables :
848 * Result :
849 * Remark :
850 * Status :
851 *
852 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
853 *****************************************************************************/
854
855BOOL HMDeviceHandler::PulseEvent(PHMHANDLEDATA pHMHandleData)
856{
857 dprintf(("KERNEL32: HandleManager::DeviceHandler::PulseEvent(%08xh)\n",
858 pHMHandleData->hHMHandle));
859
860 return (ERROR_INVALID_FUNCTION);
861}
862
863
864/*****************************************************************************
865 * Name : HMResetEvent
866 * Purpose : router function for ResetEvent
867 * Parameters:
868 * Variables :
869 * Result :
870 * Remark :
871 * Status :
872 *
873 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
874 *****************************************************************************/
875
876BOOL HMDeviceHandler::ResetEvent(PHMHANDLEDATA pHMHandleData)
877{
878 dprintf(("KERNEL32: HandleManager::DeviceHandler::ResetEvent(%08xh)\n",
879 pHMHandleData->hHMHandle));
880
881 return (ERROR_INVALID_FUNCTION);
882}
883
884
885
886/*****************************************************************************
887 * Name : DWORD HMDeviceHandler::WaitForSingleObject
888 * Purpose : object synchronization
889 * Parameters: PHMHANDLEDATA pHMHandleData
890 * DWORD dwTimeout
891 * Variables :
892 * Result : API returncode
893 * Remark :
894 * Status :
895 *
896 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
897 *****************************************************************************/
898
899DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
900 DWORD dwTimeout)
901{
902 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObject(%08xh,%08h)\n",
903 pHMHandleData->hHMHandle,
904 dwTimeout));
905
906 return(ERROR_INVALID_FUNCTION);
907}
908
909
910/*****************************************************************************
911 * Name : DWORD HMDeviceHandler::WaitForSingleObjectEx
912 * Purpose : object synchronization
913 * Parameters: PHMHANDLEDATA pHMHandleData
914 * DWORD dwTimeout
915 * BOOL fAlertable
916 * Variables :
917 * Result : API returncode
918 * Remark :
919 * Status :
920 *
921 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
922 *****************************************************************************/
923
924DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
925 DWORD dwTimeout,
926 BOOL fAlertable)
927{
928 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
929 pHMHandleData->hHMHandle,
930 dwTimeout,
931 fAlertable));
932
933 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
934 return(ERROR_INVALID_FUNCTION);
935}
936
937
938/*****************************************************************************
939 * Name : DWORD HMDeviceHandler::FlushFileBuffers
940 * Purpose : flush the buffers of a file
941 * Parameters: PHMHANDLEDATA pHMHandleData
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::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
951{
952 dprintf(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
953 pHMHandleData->hHMHandle));
954
955 return(ERROR_INVALID_FUNCTION);
956}
957
958
959/*****************************************************************************
960 * Name : DWORD HMDeviceHandler::GetOverlappedResult
961 * Purpose : asynchronus I/O
962 * Parameters: PHMHANDLEDATA pHMHandleData
963 * LPOVERLAPPED arg2
964 * LPDWORD arg3
965 * BOOL arg4
966 * Variables :
967 * Result : API returncode
968 * Remark :
969 * Status :
970 *
971 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
972 *****************************************************************************/
973
974BOOL HMDeviceHandler::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
975 LPOVERLAPPED arg2,
976 LPDWORD arg3,
977 BOOL arg4)
978{
979 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
980 pHMHandleData->hHMHandle,
981 arg2,
982 arg3,
983 arg4));
984
985 return(ERROR_INVALID_FUNCTION);
986}
987
988/*****************************************************************************
989 * Name : DWORD HMDeviceHandler::CreateFileMapping
990 * Purpose : create memory mapped file
991 * Parameters: PHMHANDLEDATA pHMHandleData
992 * LPSECURITY_ATTRIBUTES lpFileMappingAttributes
993 * DWORD flProtect
994 * DWORD dwMaximumSizeHigh
995 * DWORD dwMaximumSizeLow
996 * LPCTSTR lpName
997 * Variables :
998 * Result : API returncode
999 * Remark :
1000 * Status :
1001 *
1002 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1003 *****************************************************************************/
1004
1005DWORD HMDeviceHandler::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
1006 HANDLE hFile,
1007 LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
1008 DWORD flProtect,
1009 DWORD dwMaximumSizeHigh,
1010 DWORD dwMaximumSizeLow,
1011 LPCSTR lpName,
1012 HFILE *hOldMap) // if create an existing memmap, return handle of old one
1013{
1014 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
1015 pHMHandleData->hHMHandle,
1016 hFile,
1017 lpFileMappingAttributes,
1018 flProtect,
1019 dwMaximumSizeHigh,
1020 dwMaximumSizeLow,
1021 lpName));
1022
1023 return(ERROR_INVALID_FUNCTION);
1024}
1025
1026
1027/*****************************************************************************
1028 * Name : DWORD HMDeviceHandler::OpenFileMapping
1029 * Purpose : open memory mapped file
1030 * Parameters: PHMHANDLEDATA pHMHandleData
1031 * LPOVERLAPPED arg2
1032 * LPDWORD arg3
1033 * BOOL arg4
1034 * Variables :
1035 * Result : API returncode
1036 * Remark :
1037 * Status :
1038 *
1039 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1040 *****************************************************************************/
1041
1042DWORD HMDeviceHandler::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
1043 DWORD fdwAccess,
1044 BOOL fInherit,
1045 LPCTSTR lpName)
1046{
1047 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
1048 pHMHandleData->hHMHandle,
1049 fdwAccess,
1050 fInherit,
1051 lpName));
1052
1053 return(ERROR_INVALID_FUNCTION);
1054}
1055
1056/*****************************************************************************
1057 * Name : DWORD HMDeviceHandler::MapViewOfFile
1058 * Purpose : map memory mapped file
1059 * Parameters: PHMHANDLEDATA pHMHandleData
1060 * DWORD dwDesiredAccess,
1061 * DWORD dwFileOffsetHigh,
1062 * DWORD dwFileOffsetLow,
1063 * DWORD dwNumberOfBytesToMap
1064 * Variables :
1065 * Result : address to memory mapped region
1066 * Remark :
1067 * Status :
1068 *
1069 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1070 *****************************************************************************/
1071
1072LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
1073 DWORD dwDesiredAccess,
1074 DWORD dwFileOffsetHigh,
1075 DWORD dwFileOffsetLow,
1076 DWORD dwNumberOfBytesToMap,
1077 LPVOID lpBaseAddress)
1078{
1079 dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1080 pHMHandleData->hHMHandle,
1081 dwDesiredAccess,
1082 dwFileOffsetHigh,
1083 dwFileOffsetLow,
1084 dwNumberOfBytesToMap, lpBaseAddress));
1085
1086 return(NULL);
1087}
1088
1089/*****************************************************************************
1090 * Name : DWORD HMDeviceHandler::DeviceIoControl
1091 * Purpose : send command to device driver
1092 * Variables :
1093 * Result :
1094 * Remark :
1095 * Status :
1096 *
1097 * Author : Sander van Leeuwen
1098 *****************************************************************************/
1099
1100BOOL HMDeviceHandler::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
1101 LPVOID lpInBuffer, DWORD nInBufferSize,
1102 LPVOID lpOutBuffer, DWORD nOutBufferSize,
1103 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
1104{
1105 dprintf(("KERNEL32: HandleManager::DeviceHandler::DeviceIoControl(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1106 pHMHandleData->hHMHandle,
1107 dwIoControlCode,
1108 lpInBuffer,
1109 nInBufferSize,
1110 lpOutBuffer, nOutBufferSize));
1111
1112 return(FALSE);
1113}
1114
1115
1116/*****************************************************************************
1117 * Name : DWORD HMDeviceHandler::SetupComm
1118 * Purpose : set com port parameters (queue)
1119 * Variables :
1120 * Result :
1121 * Remark :
1122 * Status :
1123 *
1124 * Author : Achim Hasenmueller
1125 *****************************************************************************/
1126
1127BOOL HMDeviceHandler::SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue)
1128{
1129 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetupComm(%08xh,%08xh,%08xh)\n",
1130 pHMHandleData->hHMHandle,
1131 dwInQueue, dwOutQueue));
1132
1133 return(FALSE);
1134}
1135
1136
1137/*****************************************************************************
1138 * Name : DWORD HMDeviceHandler::GetCommState
1139 * Purpose : query com port control block
1140 * Variables :
1141 * Result :
1142 * Remark :
1143 * Status :
1144 *
1145 * Author : Achim Hasenmueller
1146 *****************************************************************************/
1147BOOL HMDeviceHandler::GetCommState(PHMHANDLEDATA pHMHandleData, LPDCB lpdcb)
1148{
1149 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommState(%08xh,%08xh)\n",
1150 pHMHandleData->hHMHandle,
1151 lpdcb));
1152
1153 return(FALSE);
1154}
1155
1156/*****************************************************************************
1157 * Name : DWORD HMDeviceHandler::OpenThreadToken
1158 * Purpose :
1159 * Variables :
1160 * Result :
1161 * Remark :
1162 * Status :
1163 *
1164 * Author : SvL
1165 *****************************************************************************/
1166
1167DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
1168 HANDLE ThreadHandle,
1169 BOOL OpenAsSelf)
1170{
1171 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenThreadToken(%08xh,%08xh)\n",
1172 pHMHandleData->hHMHandle,
1173 ThreadHandle));
1174
1175 return ERROR_INVALID_HANDLE;
1176}
1177
1178/*****************************************************************************
1179 * Name : DWORD HMDeviceHandler::OpenThreadToken
1180 * Purpose :
1181 * Variables :
1182 * Result :
1183 * Remark :
1184 * Status :
1185 *
1186 * Author : SvL
1187 *****************************************************************************/
1188
1189DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
1190 DWORD dwUserData,
1191 HANDLE ProcessHandle)
1192{
1193 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenProcessToken(%08xh,%08xh)\n",
1194 pHMHandleData->hHMHandle,
1195 ProcessHandle));
1196
1197 return ERROR_INVALID_HANDLE;
1198}
1199/*****************************************************************************
1200 * Name : DWORD HMDeviceHandler::CreateThread
1201 * Purpose :
1202 * Variables :
1203 * Result :
1204 * Remark :
1205 * Status :
1206 *
1207 * Author : SvL
1208 *****************************************************************************/
1209HANDLE HMDeviceHandler::CreateThread(PHMHANDLEDATA pHMHandleData,
1210 LPSECURITY_ATTRIBUTES lpsa,
1211 DWORD cbStack,
1212 LPTHREAD_START_ROUTINE lpStartAddr,
1213 LPVOID lpvThreadParm,
1214 DWORD fdwCreate,
1215 LPDWORD lpIDThread,
1216 BOOL fFirstThread)
1217{
1218 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateThread %08xh",
1219 pHMHandleData->hHMHandle));
1220
1221 return ERROR_INVALID_HANDLE;
1222}
1223/*****************************************************************************
1224 * Name : DWORD HMDeviceHandler::GetThreadPriority
1225 * Purpose :
1226 * Variables :
1227 * Result :
1228 * Remark :
1229 * Status :
1230 *
1231 * Author : SvL
1232 *****************************************************************************/
1233INT HMDeviceHandler::GetThreadPriority(PHMHANDLEDATA pHMHandleData)
1234{
1235 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadPriority %08xh",
1236 pHMHandleData->hHMHandle));
1237
1238 return ERROR_INVALID_HANDLE;
1239}
1240/*****************************************************************************
1241 * Name : DWORD HMDeviceHandler::SuspendThread
1242 * Purpose :
1243 * Variables :
1244 * Result :
1245 * Remark :
1246 * Status :
1247 *
1248 * Author : SvL
1249 *****************************************************************************/
1250DWORD HMDeviceHandler::SuspendThread(PHMHANDLEDATA pHMHandleData)
1251{
1252 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SuspendThread %08xh",
1253 pHMHandleData->hHMHandle));
1254
1255 return ERROR_INVALID_HANDLE;
1256}
1257/*****************************************************************************
1258 * Name : DWORD HMDeviceHandler::SetThreadPriority
1259 * Purpose :
1260 * Variables :
1261 * Result :
1262 * Remark :
1263 * Status :
1264 *
1265 * Author : SvL
1266 *****************************************************************************/
1267BOOL HMDeviceHandler::SetThreadPriority(PHMHANDLEDATA pHMHandleData, int priority)
1268{
1269 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadPriority %08xh",
1270 pHMHandleData->hHMHandle));
1271
1272 return ERROR_INVALID_HANDLE;
1273}
1274/*****************************************************************************
1275 * Name : DWORD HMDeviceHandler::GetThreadContext
1276 * Purpose :
1277 * Variables :
1278 * Result :
1279 * Remark :
1280 * Status :
1281 *
1282 * Author : SvL
1283 *****************************************************************************/
1284BOOL HMDeviceHandler::GetThreadContext(PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext)
1285{
1286 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadContext %08xh",
1287 pHMHandleData->hHMHandle));
1288
1289 return ERROR_INVALID_HANDLE;
1290}
1291/*****************************************************************************
1292 * Name : DWORD HMDeviceHandler::SetThreadContext
1293 * Purpose :
1294 * Variables :
1295 * Result :
1296 * Remark :
1297 * Status :
1298 *
1299 * Author : SvL
1300 *****************************************************************************/
1301BOOL HMDeviceHandler::SetThreadContext(PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext)
1302{
1303 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadContext %08xh",
1304 pHMHandleData->hHMHandle));
1305
1306 return ERROR_INVALID_HANDLE;
1307}
1308/*****************************************************************************
1309 * Name : DWORD HMDeviceHandler::TerminateThread
1310 * Purpose :
1311 * Variables :
1312 * Result :
1313 * Remark :
1314 * Status :
1315 *
1316 * Author : SvL
1317 *****************************************************************************/
1318BOOL HMDeviceHandler::TerminateThread(PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1319{
1320 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1321 pHMHandleData->hHMHandle));
1322
1323 return ERROR_INVALID_HANDLE;
1324}
1325/*****************************************************************************
1326 * Name : DWORD HMDeviceHandler::ResumeThread
1327 * Purpose :
1328 * Variables :
1329 * Result :
1330 * Remark :
1331 * Status :
1332 *
1333 * Author : SvL
1334 *****************************************************************************/
1335DWORD HMDeviceHandler::ResumeThread(PHMHANDLEDATA pHMHandleData)
1336{
1337 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1338 pHMHandleData->hHMHandle));
1339
1340 return ERROR_INVALID_HANDLE;
1341}
1342/*****************************************************************************
1343 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1344 * Purpose :
1345 * Variables :
1346 * Result :
1347 * Remark :
1348 * Status :
1349 *
1350 * Author : SvL
1351 *****************************************************************************/
1352BOOL HMDeviceHandler::GetExitCodeThread(PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1353{
1354 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1355 pHMHandleData->hHMHandle));
1356
1357 return ERROR_INVALID_HANDLE;
1358}
1359/*****************************************************************************
1360 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1361 * Purpose :
1362 * Variables :
1363 * Result :
1364 * Remark :
1365 * Status :
1366 *
1367 * Author : SvL
1368 *****************************************************************************/
1369BOOL HMDeviceHandler::SetThreadTerminated(PHMHANDLEDATA pHMHandleData)
1370{
1371 return FALSE;
1372}
Note: See TracBrowser for help on using the repository browser.