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

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

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