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

Last change on this file since 9653 was 9653, checked in by sandervl, 23 years ago

implemented Get/SetHandleInformation; CloseHandle change for HANDLE_FLAG_PROTECT_FROM_CLOSE; inheritance support added to DuplicateHandle
File size: 64.1 KB
Line 
1/* $Id: hmdevice.cpp,v 1.33 2003-01-10 12:57:12 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 <string.h>
23#include <misc.h>
24#include "HandleManager.h"
25#include "HMDevice.h"
26
27#define DBG_LOCALLOG DBG_hmdevice
28#include "dbglocal.h"
29
30
31/*****************************************************************************
32 * Defines *
33 *****************************************************************************/
34
35#ifndef ERROR_INVALID_FUNCTION
36#define ERROR_INVALID_FUNCTION 1
37#endif
38
39/*****************************************************************************
40 * Structures *
41 *****************************************************************************/
42
43
44/*****************************************************************************
45 * This pseudo-device logs all device requests to the logfile and returns *
46 * ERROR_INVALID_FUNCTION to virtually all requests -> debugging *
47 *****************************************************************************/
48class HMDeviceDebugClass : public HMDeviceHandler
49{
50 public:
51 HMDeviceDebugClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
52};
53
54
55/*****************************************************************************
56 * Name : HMDeviceHandler::HMDeviceHandler
57 * Purpose : default constructor for a device handler object
58 * Parameters: LPCSTR lpDeviceName
59 * Variables :
60 * Result :
61 * Remark : this is only to identify the device for debugging purposes
62 * Status :
63 *
64 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
65 *****************************************************************************/
66
67HMDeviceHandler::HMDeviceHandler(LPCSTR lpDeviceName)
68{
69 /* only a reference on the device name */
70 HMDeviceHandler::lpHMDeviceName = lpDeviceName;
71}
72
73
74/*****************************************************************************
75 * Name : HMDeviceHandler::FindDevice
76 * Purpose : Checks if lpDeviceName belongs to this device class
77 * Parameters: LPCSTR lpClassDevName
78 * LPCSTR lpDeviceName
79 * int namelength
80 * Variables :
81 * Result :
82 * Remark :
83 * Status :
84 *
85 * Author : SvL
86 *****************************************************************************/
87BOOL HMDeviceHandler::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
88{
89 if(stricmp(lpClassDevName, lpDeviceName) == 0) {
90 return TRUE;
91 }
92 return FALSE;
93}
94
95/*****************************************************************************
96 * Name : HMDeviceHandler::_DeviceReuqest
97 * Purpose : entry method for special request functions
98 * Parameters: ULONG ulRequestCode
99 * various parameters as required
100 * Variables :
101 * Result :
102 * Remark : the standard behaviour is to return an error code for non-
103 * existant request codes
104 * Status :
105 *
106 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
107 *****************************************************************************/
108DWORD HMDeviceHandler::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
109 ULONG ulRequestCode,
110 ULONG arg1,
111 ULONG arg2,
112 ULONG arg3,
113 ULONG arg4)
114{
115 dprintf(("KERNEL32:HandleManager::_DeviceRequest %s(%08x,%08x) - stub?\n",
116 lpHMDeviceName,
117 pHMHandleData,
118 ulRequestCode));
119
120 return(ERROR_INVALID_FUNCTION);
121}
122
123
124/*****************************************************************************
125 * Name : HMDeviceHandler::DuplicateHandle
126 * Purpose : dummy version
127 * Parameters:
128 * various parameters as required
129 * Variables :
130 * Result :
131 * Remark : the standard behaviour is to return an error code for non-
132 * existant request codes
133 * Status :
134 *
135 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
136 *****************************************************************************/
137BOOL HMDeviceHandler::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
138 PHMHANDLEDATA pHMSrcHandle,
139 HANDLE destprocess,
140 PHANDLE desthandle,
141 DWORD fdwAccess,
142 BOOL fInherit,
143 DWORD fdwOptions,
144 DWORD fdwOdinOptions)
145{
146 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",
147 lpHMDeviceName,
148 pHMHandleData,
149 srcprocess, pHMSrcHandle, destprocess, desthandle));
150
151 return FALSE;
152}
153
154/*****************************************************************************
155 * Name : DWORD HMDeviceHandler::CreateFile
156 * Purpose : this is called from the handle manager if a CreateFile() is
157 * performed on a handle
158 * Parameters: LPCSTR lpFileName name of the file / device
159 * PHMHANDLEDATA pHMHandleData data of the NEW handle
160 * PVOID lpSecurityAttributes ignored
161 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
162 * Variables :
163 * Result :
164 * Remark :
165 * Status : NO_ERROR - API succeeded
166 * other - what is to be set in SetLastError
167 *
168 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
169 *****************************************************************************/
170
171DWORD HMDeviceHandler::CreateFile (LPCSTR lpFileName,
172 PHMHANDLEDATA pHMHandleData,
173 PVOID lpSecurityAttributes,
174 PHMHANDLEDATA pHMHandleDataTemplate)
175{
176 dprintf(("KERNEL32:HandleManager::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
177 lpHMDeviceName,
178 lpFileName,
179 pHMHandleData,
180 lpSecurityAttributes,
181 pHMHandleDataTemplate));
182
183 return(ERROR_INVALID_FUNCTION);
184}
185
186
187/*****************************************************************************
188 * Name : DWORD HMDeviceHandler::CloseHandle
189 * Purpose : close the handle
190 * Parameters: PHMHANDLEDATA pHMHandleData
191 * Variables :
192 * Result : API returncode
193 * Remark :
194 * Status :
195 *
196 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
197 *****************************************************************************/
198
199BOOL HMDeviceHandler::CloseHandle(PHMHANDLEDATA pHMHandleData)
200{
201 dprintf(("KERNEL32:HandleManager::CloseHandle %s(%08x) - stub?\n",
202 lpHMDeviceName,
203 pHMHandleData));
204
205 SetLastError(ERROR_INVALID_FUNCTION);
206 return FALSE;
207}
208
209/*****************************************************************************
210 * Name : BOOL HMSetHandleInformation
211 * Purpose : The SetHandleInformation function sets certain properties of an
212 * object handle. The information is specified as a set of bit flags.
213 * Parameters: HANDLE hObject handle to an object
214 * DWORD dwMask specifies flags to change
215 * DWORD dwFlags specifies new values for flags
216 * Variables :
217 * Result : TRUE / FALSE
218 * Remark :
219 * Status :
220 *
221 * Author : SvL
222 *****************************************************************************/
223BOOL HMDeviceHandler::SetHandleInformation(PHMHANDLEDATA pHMHandleData,
224 DWORD dwMask,
225 DWORD dwFlags)
226{
227 dprintf(("KERNEL32:HandleManager::SetHandleInformation %s(%08x) - stub?\n",
228 lpHMDeviceName,
229 pHMHandleData));
230
231 SetLastError(ERROR_INVALID_FUNCTION);
232 return FALSE;
233}
234
235
236/*****************************************************************************
237 * Name : BOOL HMDeviceHandler::ReadFile
238 * Purpose : read data from handle / device
239 * Parameters: PHMHANDLEDATA pHMHandleData,
240 * LPCVOID lpBuffer,
241 * DWORD nNumberOfBytesToRead,
242 * LPDWORD lpNumberOfBytesRead,
243 * LPOVERLAPPED lpOverlapped
244 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
245 * Variables :
246 * Result : Boolean
247 * Remark :
248 * Status :
249 *
250 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
251 *****************************************************************************/
252
253BOOL HMDeviceHandler::ReadFile(PHMHANDLEDATA pHMHandleData,
254 LPCVOID lpBuffer,
255 DWORD nNumberOfBytesToRead,
256 LPDWORD lpNumberOfBytesRead,
257 LPOVERLAPPED lpOverlapped,
258 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
259{
260 dprintf(("KERNEL32:HandleManager::ReadFile %s(%08x,%08x,%08x,%08x,%08x %08x) - stub?\n",
261 lpHMDeviceName,
262 pHMHandleData->hHMHandle,
263 lpBuffer,
264 nNumberOfBytesToRead,
265 lpNumberOfBytesRead,
266 lpOverlapped, lpCompletionRoutine));
267
268 SetLastError(ERROR_INVALID_FUNCTION);
269 return FALSE;
270}
271
272
273/*****************************************************************************
274 * Name : BOOL HMDeviceHandler::WriteFile
275 * Purpose : write data to handle / device
276 * Parameters: PHMHANDLEDATA pHMHandleData,
277 * LPCVOID lpBuffer,
278 * DWORD nNumberOfBytesToWrite,
279 * LPDWORD lpNumberOfBytesWritten,
280 * LPOVERLAPPED lpOverlapped
281 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
282 * Variables :
283 * Result : Boolean
284 * Remark :
285 * Status :
286 *
287 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
288 *****************************************************************************/
289
290BOOL HMDeviceHandler::WriteFile(PHMHANDLEDATA pHMHandleData,
291 LPCVOID lpBuffer,
292 DWORD nNumberOfBytesToWrite,
293 LPDWORD lpNumberOfBytesWritten,
294 LPOVERLAPPED lpOverlapped,
295 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
296{
297 dprintf(("KERNEL32:HandleManager::WriteFile %s(%08x,%08x,%08x,%08x,%08x,%08x) - stub?\n",
298 lpHMDeviceName,
299 pHMHandleData->hHMHandle,
300 lpBuffer,
301 nNumberOfBytesToWrite,
302 lpNumberOfBytesWritten,
303 lpOverlapped, lpCompletionRoutine));
304
305 SetLastError(ERROR_INVALID_FUNCTION);
306 return FALSE;
307}
308
309/*****************************************************************************
310 * Name : DWORD HMDeviceHandler::GetFileType
311 * Purpose : determine the handle type
312 * Parameters: PHMHANDLEDATA pHMHandleData
313 * Variables :
314 * Result : API returncode
315 * Remark :
316 * Status :
317 *
318 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
319 *****************************************************************************/
320
321DWORD HMDeviceHandler::GetFileType(PHMHANDLEDATA pHMHandleData)
322{
323 dprintf(("KERNEL32:HandleManager::GetFileType %s(%08x)\n",
324 lpHMDeviceName,
325 pHMHandleData));
326
327 return FILE_TYPE_UNKNOWN;
328}
329
330
331/*****************************************************************************
332 * Name : DWORD HMDeviceHandler::GetFileInformationByHandle
333 * Purpose : determine the handle type
334 * Parameters: PHMHANDLEDATA pHMHandleData
335 * BY_HANDLE_FILE_INFORMATION* pHFI
336 * Variables :
337 * Result : API returncode
338 * Remark :
339 * Status :
340 *
341 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
342 *****************************************************************************/
343
344DWORD HMDeviceHandler::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
345 BY_HANDLE_FILE_INFORMATION* pHFI)
346{
347 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileInformationByHandle %s(%08xh,%08xh)\n",
348 lpHMDeviceName,
349 pHMHandleData,
350 pHFI));
351
352 return(ERROR_INVALID_FUNCTION);
353}
354
355
356/*****************************************************************************
357 * Name : BOOL HMDeviceHandler::SetEndOfFile
358 * Purpose : set end of file marker
359 * Parameters: PHMHANDLEDATA pHMHandleData
360 * Variables :
361 * Result : API returncode
362 * Remark :
363 * Status :
364 *
365 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
366 *****************************************************************************/
367
368BOOL HMDeviceHandler::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
369{
370 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetEndOfFile %s(%08xh)\n",
371 lpHMDeviceName,
372 pHMHandleData));
373
374 return(ERROR_INVALID_FUNCTION);
375}
376
377
378/*****************************************************************************
379 * Name : BOOL HMDeviceHandler::SetFileTime
380 * Purpose : set file time
381 * Parameters: PHMHANDLEDATA pHMHandleData
382 * PFILETIME pFT1
383 * PFILETIME pFT2
384 * PFILETIME pFT3
385 * Variables :
386 * Result : API returncode
387 * Remark :
388 * Status :
389 *
390 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
391 *****************************************************************************/
392
393BOOL HMDeviceHandler::SetFileTime(PHMHANDLEDATA pHMHandleData,
394 LPFILETIME pFT1,
395 LPFILETIME pFT2,
396 LPFILETIME pFT3)
397{
398 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
399 lpHMDeviceName,
400 pHMHandleData,
401 pFT1,
402 pFT2,
403 pFT3));
404
405 return(ERROR_INVALID_FUNCTION);
406}
407
408/*****************************************************************************
409 * Name : BOOL HMDeviceHandler::GetFileTime
410 * Purpose : get file time
411 * Parameters: PHMHANDLEDATA pHMHandleData
412 * PFILETIME pFT1
413 * PFILETIME pFT2
414 * PFILETIME pFT3
415 * Variables :
416 * Result : API returncode
417 * Remark :
418 * Status :
419 *
420 * Author : SvL
421 *****************************************************************************/
422
423BOOL HMDeviceHandler::GetFileTime(PHMHANDLEDATA pHMHandleData,
424 LPFILETIME pFT1,
425 LPFILETIME pFT2,
426 LPFILETIME pFT3)
427{
428 DebugInt3();
429 return(ERROR_INVALID_FUNCTION);
430}
431
432
433/*****************************************************************************
434 * Name : DWORD HMDeviceHandler::GetFileSize
435 * Purpose : set file time
436 * Parameters: PHMHANDLEDATA pHMHandleData
437 * PDWORD pSize
438 * Variables :
439 * Result : API returncode
440 * Remark :
441 * Status :
442 *
443 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
444 *****************************************************************************/
445
446DWORD HMDeviceHandler::GetFileSize(PHMHANDLEDATA pHMHandleData,
447 PDWORD pSize)
448{
449 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileSize %s(%08xh,%08xh)\n",
450 lpHMDeviceName,
451 pHMHandleData,
452 pSize));
453
454 return -1; //INVALID_SET_FILE_POINTER
455}
456
457
458/*****************************************************************************
459 * Name : DWORD HMDeviceHandler::SetFilePointer
460 * Purpose : set file pointer
461 * Parameters: PHMHANDLEDATA pHMHandleData
462 * LONG lDistanceToMove
463 * PLONG lpDistanceToMoveHigh
464 * DWORD dwMoveMethod
465 * Variables :
466 * Result : API returncode
467 * Remark :
468 * Status :
469 *
470 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
471 *****************************************************************************/
472
473DWORD HMDeviceHandler::SetFilePointer(PHMHANDLEDATA pHMHandleData,
474 LONG lDistanceToMove,
475 PLONG lpDistanceToMoveHigh,
476 DWORD dwMoveMethod)
477{
478 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
479 lpHMDeviceName,
480 pHMHandleData,
481 lDistanceToMove,
482 lpDistanceToMoveHigh,
483 dwMoveMethod));
484
485 return(ERROR_INVALID_FUNCTION);
486}
487
488
489/*****************************************************************************
490 * Name : DWORD HMDeviceHandler::LockFile
491 * Purpose : file locking
492 * Parameters: PHMHANDLEDATA pHMHandleData
493 * DWORD arg2
494 * DWORD arg3
495 * DWORD arg4
496 * DWORD arg5
497 * Variables :
498 * Result : API returncode
499 * Remark :
500 * Status :
501 *
502 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
503 *****************************************************************************/
504
505DWORD HMDeviceHandler::LockFile(PHMHANDLEDATA pHMHandleData,
506 DWORD arg2,
507 DWORD arg3,
508 DWORD arg4,
509 DWORD arg5)
510{
511 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
512 lpHMDeviceName,
513 pHMHandleData,
514 arg2,
515 arg3,
516 arg4,
517 arg5));
518
519 return(ERROR_INVALID_FUNCTION);
520}
521
522
523
524/*****************************************************************************
525 * Name : DWORD HMDeviceHandler::LockFileEx
526 * Purpose : file locking
527 * Parameters: PHMHANDLEDATA pHMHandleData
528 * DWORD dwFlags
529 * DWORD dwReserved
530 * DWORD nNumberOfBytesToLockLow
531 * DWORD nNumberOfBytesToLockHigh
532 * LPOVERLAPPED lpOverlapped
533 * Variables :
534 * Result : API returncode
535 * Remark :
536 * Status :
537 *
538 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
539 *****************************************************************************/
540
541DWORD HMDeviceHandler::LockFileEx(PHMHANDLEDATA pHMHandleData,
542 DWORD dwFlags,
543 DWORD dwReserved,
544 DWORD nNumberOfBytesToLockLow,
545 DWORD nNumberOfBytesToLockHigh,
546 LPOVERLAPPED lpOverlapped)
547{
548
549 dprintf(("KERNEL32: HandleManager::DeviceHandler::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
550 lpHMDeviceName,
551 pHMHandleData,
552 dwFlags,
553 dwReserved,
554 nNumberOfBytesToLockLow,
555 nNumberOfBytesToLockHigh,
556 lpOverlapped));
557
558 return(ERROR_INVALID_FUNCTION);
559}
560
561
562/*****************************************************************************
563 * Name : DWORD HMDeviceHandler::OpenFile
564 * Purpose : this is called from the handle manager if a OpenFile() is
565 * performed on a handle
566 * Parameters: LPCSTR lpFileName name of the file / device
567 * PHMHANDLEDATA pHMHandleData data of the NEW handle
568 * PVOID lpSecurityAttributes ignored
569 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
570 * Variables :
571 * Result :
572 * Remark :
573 * Status : NO_ERROR - API succeeded
574 * other - what is to be set in SetLastError
575 *
576 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
577 *****************************************************************************/
578
579DWORD HMDeviceHandler::OpenFile (LPCSTR lpFileName,
580 PHMHANDLEDATA pHMHandleData,
581 OFSTRUCT *pOFStruct,
582 UINT arg3)
583{
584 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
585 lpHMDeviceName,
586 lpFileName,
587 pHMHandleData,
588 pOFStruct,
589 arg3));
590
591 return(ERROR_INVALID_FUNCTION);
592}
593
594
595/*****************************************************************************
596 * Name : DWORD HMDeviceHandler::UnlockFile
597 * Purpose : file locking
598 * Parameters: PHMHANDLEDATA pHMHandleData
599 * DWORD arg2
600 * DWORD arg3
601 * DWORD arg4
602 * DWORD arg5
603 * Variables :
604 * Result : API returncode
605 * Remark :
606 * Status :
607 *
608 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
609 *****************************************************************************/
610
611DWORD HMDeviceHandler::UnlockFile(PHMHANDLEDATA pHMHandleData,
612 DWORD arg2,
613 DWORD arg3,
614 DWORD arg4,
615 DWORD arg5)
616{
617 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
618 lpHMDeviceName,
619 pHMHandleData,
620 arg2,
621 arg3,
622 arg4,
623 arg5));
624
625 return(ERROR_INVALID_FUNCTION);
626}
627
628
629
630/*****************************************************************************
631 * Name : DWORD HMDeviceHandler::UnlockFileEx
632 * Purpose : file locking
633 * Parameters: PHMHANDLEDATA pHMHandleData
634 * DWORD dwReserved
635 * DWORD nNumberOfBytesToLockLow
636 * DWORD nNumberOfBytesToLockHigh
637 * LPOVERLAPPED lpOverlapped
638 * Variables :
639 * Result : API returncode
640 * Remark :
641 * Status :
642 *
643 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
644 *****************************************************************************/
645
646DWORD HMDeviceHandler::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
647 DWORD dwReserved,
648 DWORD nNumberOfBytesToLockLow,
649 DWORD nNumberOfBytesToLockHigh,
650 LPOVERLAPPED lpOverlapped)
651{
652 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFileEx %s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
653 lpHMDeviceName,
654 pHMHandleData,
655 dwReserved,
656 nNumberOfBytesToLockLow,
657 nNumberOfBytesToLockHigh,
658 lpOverlapped));
659
660 return(ERROR_INVALID_FUNCTION);
661}
662
663
664
665/*****************************************************************************
666 * Name : HMCreateSemaphore
667 * Purpose : router function for CreateSemaphore
668 * Parameters:
669 * Variables :
670 * Result :
671 * Remark :
672 * Status :
673 *
674 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
675 *****************************************************************************/
676
677DWORD HMDeviceHandler::CreateSemaphore(PHMHANDLEDATA pHMHandleData,
678 LPSECURITY_ATTRIBUTES lpsa,
679 LONG lInitialCount,
680 LONG lMaximumCount,
681 LPCTSTR lpszSemaphoreName)
682{
683 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateSemaphore(%08xh,%08xh,%08xh,%08xh,%s)\n",
684 pHMHandleData,
685 lpsa,
686 lInitialCount,
687 lMaximumCount,
688 lpszSemaphoreName));
689
690 return (ERROR_INVALID_FUNCTION);
691}
692
693
694/*****************************************************************************
695 * Name : HMOpenSemaphore
696 * Purpose : router function for OpenSemaphore
697 * Parameters:
698 * Variables :
699 * Result :
700 * Remark :
701 * Status :
702 *
703 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
704 *****************************************************************************/
705
706DWORD HMDeviceHandler::OpenSemaphore(PHMHANDLEDATA pHMHandleData,
707 BOOL fInheritHandle,
708 LPCTSTR lpszSemaphoreName)
709{
710 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenSemaphore(%08xh,%08xh,%s)\n",
711 pHMHandleData,
712 fInheritHandle,
713 lpszSemaphoreName));
714
715 return (ERROR_INVALID_FUNCTION);
716}
717
718
719/*****************************************************************************
720 * Name : HMReleaseSemaphore
721 * Purpose : router function for ReleaseSemaphore
722 * Parameters:
723 * Variables :
724 * Result :
725 * Remark :
726 * Status :
727 *
728 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
729 *****************************************************************************/
730
731BOOL HMDeviceHandler::ReleaseSemaphore(PHMHANDLEDATA pHMHandleData,
732 LONG cReleaseCount,
733 LPLONG lpPreviousCount)
734{
735 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseSemaphore(%08xh,%08xh,%08xh)\n",
736 pHMHandleData->hHMHandle,
737 cReleaseCount,
738 lpPreviousCount));
739
740 return (ERROR_INVALID_FUNCTION);
741}
742
743
744
745/*****************************************************************************
746 * Name : HMCreateMutex
747 * Purpose : router function for CreateMutex
748 * Parameters:
749 * Variables :
750 * Result :
751 * Remark :
752 * Status :
753 *
754 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
755 *****************************************************************************/
756
757DWORD HMDeviceHandler::CreateMutex(PHMHANDLEDATA pHMHandleData,
758 LPSECURITY_ATTRIBUTES lpsa,
759 BOOL fInitialOwner,
760 LPCTSTR lpszMutexName)
761{
762 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateMutex(%08xh,%08xh,%08xh,%s)\n",
763 pHMHandleData,
764 lpsa,
765 fInitialOwner,
766 lpszMutexName));
767
768 return (ERROR_INVALID_FUNCTION);
769}
770
771
772/*****************************************************************************
773 * Name : HMOpenMutex
774 * Purpose : router function for OpenMutex
775 * Parameters:
776 * Variables :
777 * Result :
778 * Remark :
779 * Status :
780 *
781 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
782 *****************************************************************************/
783
784DWORD HMDeviceHandler::OpenMutex(PHMHANDLEDATA pHMHandleData,
785 BOOL fInheritHandle,
786 LPCTSTR lpszMutexName)
787{
788 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenMutex(%08xh,%08xh,%s)\n",
789 pHMHandleData,
790 fInheritHandle,
791 lpszMutexName));
792
793 return (ERROR_INVALID_FUNCTION);
794}
795
796
797/*****************************************************************************
798 * Name : HMReleaseMutex
799 * Purpose : router function for ReleaseMutex
800 * Parameters:
801 * Variables :
802 * Result :
803 * Remark :
804 * Status :
805 *
806 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
807 *****************************************************************************/
808
809BOOL HMDeviceHandler::ReleaseMutex(PHMHANDLEDATA pHMHandleData)
810{
811 dprintf(("KERNEL32: HandleManager::DeviceHandler::ReleaseMutex(%08xh)\n",
812 pHMHandleData->hHMHandle));
813
814 return (ERROR_INVALID_FUNCTION);
815}
816
817
818/*****************************************************************************
819 * Name : HMCreateEvent
820 * Purpose : router function for CreateEvent
821 * Parameters:
822 * Variables :
823 * Result :
824 * Remark :
825 * Status :
826 *
827 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
828 *****************************************************************************/
829
830DWORD HMDeviceHandler::CreateEvent(PHMHANDLEDATA pHMHandleData,
831 LPSECURITY_ATTRIBUTES lpsa,
832 BOOL fManualReset,
833 BOOL fInitialState,
834 LPCTSTR lpszEventName)
835{
836 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateEvent(%08xh,%08xh,%08xh,%08xh,%s)\n",
837 pHMHandleData,
838 lpsa,
839 fManualReset,
840 fInitialState,
841 lpszEventName));
842
843 return (ERROR_INVALID_FUNCTION);
844}
845
846
847/*****************************************************************************
848 * Name : HMOpenEvent
849 * Purpose : router function for OpenEvent
850 * Parameters:
851 * Variables :
852 * Result :
853 * Remark :
854 * Status :
855 *
856 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
857 *****************************************************************************/
858
859DWORD HMDeviceHandler::OpenEvent(PHMHANDLEDATA pHMHandleData,
860 BOOL fInheritHandle,
861 LPCTSTR lpszEventName)
862{
863 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenEvent(%08xh,%08xh,%s)\n",
864 pHMHandleData,
865 fInheritHandle,
866 lpszEventName));
867
868 return (ERROR_INVALID_FUNCTION);
869}
870
871
872/*****************************************************************************
873 * Name : HMSetEvent
874 * Purpose : router function for SetEvent
875 * Parameters:
876 * Variables :
877 * Result :
878 * Remark :
879 * Status :
880 *
881 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
882 *****************************************************************************/
883
884BOOL HMDeviceHandler::SetEvent(PHMHANDLEDATA pHMHandleData)
885{
886 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetEvent(%08xh)\n",
887 pHMHandleData->hHMHandle));
888
889 return (ERROR_INVALID_FUNCTION);
890}
891
892
893/*****************************************************************************
894 * Name : HMPulseEvent
895 * Purpose : router function for PulseEvent
896 * Parameters:
897 * Variables :
898 * Result :
899 * Remark :
900 * Status :
901 *
902 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
903 *****************************************************************************/
904
905BOOL HMDeviceHandler::PulseEvent(PHMHANDLEDATA pHMHandleData)
906{
907 dprintf(("KERNEL32: HandleManager::DeviceHandler::PulseEvent(%08xh)\n",
908 pHMHandleData->hHMHandle));
909
910 return (ERROR_INVALID_FUNCTION);
911}
912
913
914/*****************************************************************************
915 * Name : HMResetEvent
916 * Purpose : router function for ResetEvent
917 * Parameters:
918 * Variables :
919 * Result :
920 * Remark :
921 * Status :
922 *
923 * Author : Patrick Haller [Tue, 1999/07/06 20:44]
924 *****************************************************************************/
925
926BOOL HMDeviceHandler::ResetEvent(PHMHANDLEDATA pHMHandleData)
927{
928 dprintf(("KERNEL32: HandleManager::DeviceHandler::ResetEvent(%08xh)\n",
929 pHMHandleData->hHMHandle));
930
931 return (ERROR_INVALID_FUNCTION);
932}
933
934
935
936
937/*****************************************************************************
938 * Name : DWORD HMDeviceHandler::FlushFileBuffers
939 * Purpose : flush the buffers of a file
940 * Parameters: PHMHANDLEDATA pHMHandleData
941 * Variables :
942 * Result : API returncode
943 * Remark :
944 * Status :
945 *
946 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
947 *****************************************************************************/
948
949BOOL HMDeviceHandler::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
950{
951 dprintf(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
952 pHMHandleData->hHMHandle));
953
954 return(ERROR_INVALID_FUNCTION);
955}
956
957
958/*****************************************************************************
959 * Name : DWORD HMDeviceHandler::GetOverlappedResult
960 * Purpose : asynchronus I/O
961 * Parameters: PHMHANDLEDATA pHMHandleData
962 * LPOVERLAPPED arg2
963 * LPDWORD arg3
964 * BOOL arg4
965 * Variables :
966 * Result : API returncode
967 * Remark :
968 * Status :
969 *
970 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
971 *****************************************************************************/
972
973BOOL HMDeviceHandler::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
974 LPOVERLAPPED arg2,
975 LPDWORD arg3,
976 BOOL arg4)
977{
978 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
979 pHMHandleData->hHMHandle,
980 arg2,
981 arg3,
982 arg4));
983
984 return(ERROR_INVALID_FUNCTION);
985}
986
987/*****************************************************************************
988 * Name : DWORD HMDeviceHandler::CreateFileMapping
989 * Purpose : create memory mapped file
990 * Parameters: PHMHANDLEDATA pHMHandleData
991 * LPSECURITY_ATTRIBUTES lpFileMappingAttributes
992 * DWORD flProtect
993 * DWORD dwMaximumSizeHigh
994 * DWORD dwMaximumSizeLow
995 * LPCTSTR lpName
996 * Variables :
997 * Result : API returncode
998 * Remark :
999 * Status :
1000 *
1001 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1002 *****************************************************************************/
1003
1004DWORD HMDeviceHandler::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
1005 HANDLE hFile,
1006 LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
1007 DWORD flProtect,
1008 DWORD dwMaximumSizeHigh,
1009 DWORD dwMaximumSizeLow,
1010 LPCSTR lpName)
1011{
1012 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
1013 pHMHandleData->hHMHandle,
1014 hFile,
1015 lpFileMappingAttributes,
1016 flProtect,
1017 dwMaximumSizeHigh,
1018 dwMaximumSizeLow,
1019 lpName));
1020
1021 return(ERROR_INVALID_FUNCTION);
1022}
1023
1024
1025/*****************************************************************************
1026 * Name : DWORD HMDeviceHandler::OpenFileMapping
1027 * Purpose : open memory mapped file
1028 * Parameters: PHMHANDLEDATA pHMHandleData
1029 * LPOVERLAPPED arg2
1030 * LPDWORD arg3
1031 * BOOL arg4
1032 * Variables :
1033 * Result : API returncode
1034 * Remark :
1035 * Status :
1036 *
1037 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1038 *****************************************************************************/
1039
1040DWORD HMDeviceHandler::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
1041 DWORD fdwAccess,
1042 BOOL fInherit,
1043 LPCTSTR lpName)
1044{
1045 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
1046 pHMHandleData->hHMHandle,
1047 fdwAccess,
1048 fInherit,
1049 lpName));
1050
1051 return(ERROR_INVALID_FUNCTION);
1052}
1053
1054/*****************************************************************************
1055 * Name : DWORD HMDeviceHandler::MapViewOfFile
1056 * Purpose : map memory mapped file
1057 * Parameters: PHMHANDLEDATA pHMHandleData
1058 * DWORD dwDesiredAccess,
1059 * DWORD dwFileOffsetHigh,
1060 * DWORD dwFileOffsetLow,
1061 * DWORD dwNumberOfBytesToMap
1062 * Variables :
1063 * Result : address to memory mapped region
1064 * Remark :
1065 * Status :
1066 *
1067 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1068 *****************************************************************************/
1069
1070LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
1071 DWORD dwDesiredAccess,
1072 DWORD dwFileOffsetHigh,
1073 DWORD dwFileOffsetLow,
1074 DWORD dwNumberOfBytesToMap,
1075 LPVOID lpBaseAddress)
1076{
1077 dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1078 pHMHandleData->hHMHandle,
1079 dwDesiredAccess,
1080 dwFileOffsetHigh,
1081 dwFileOffsetLow,
1082 dwNumberOfBytesToMap, lpBaseAddress));
1083
1084 return(NULL);
1085}
1086
1087/*****************************************************************************
1088 * Name : DWORD HMDeviceHandler::DeviceIoControl
1089 * Purpose : send command to device driver
1090 * Variables :
1091 * Result :
1092 * Remark :
1093 * Status :
1094 *
1095 * Author : Sander van Leeuwen
1096 *****************************************************************************/
1097
1098BOOL HMDeviceHandler::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
1099 LPVOID lpInBuffer, DWORD nInBufferSize,
1100 LPVOID lpOutBuffer, DWORD nOutBufferSize,
1101 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
1102{
1103 dprintf(("KERNEL32: HandleManager::DeviceHandler::DeviceIoControl(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1104 pHMHandleData->hHMHandle,
1105 dwIoControlCode,
1106 lpInBuffer,
1107 nInBufferSize,
1108 lpOutBuffer, nOutBufferSize));
1109
1110 return(FALSE);
1111}
1112
1113/*****************************************************************************
1114 * Name : DWORD HMDeviceHandler::CancelIo
1115 * Purpose : cancel pending IO operation
1116 * Variables :
1117 * Result :
1118 * Remark :
1119 * Status :
1120 *
1121 * Author : SvL
1122 *****************************************************************************/
1123BOOL HMDeviceHandler::CancelIo(PHMHANDLEDATA pHMHandleData)
1124{
1125 dprintf(("KERNEL32: HandleManager::DeviceHandler::CancelIo(%08xh)",
1126 pHMHandleData->hHMHandle));
1127 SetLastError(ERROR_INVALID_HANDLE);
1128 return(FALSE);
1129}
1130/*****************************************************************************
1131 * Name : DWORD HMDeviceHandler::SetupComm
1132 * Purpose : set com port parameters (queue)
1133 * Variables :
1134 * Result :
1135 * Remark :
1136 * Status :
1137 *
1138 * Author : Achim Hasenmueller
1139 *****************************************************************************/
1140
1141BOOL HMDeviceHandler::SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue)
1142{
1143 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetupComm(%08xh,%08xh,%08xh)\n",
1144 pHMHandleData->hHMHandle,
1145 dwInQueue, dwOutQueue));
1146 SetLastError(ERROR_INVALID_HANDLE);
1147 return(FALSE);
1148}
1149
1150
1151/*****************************************************************************
1152 * Name : DWORD HMDeviceHandler::GetCommState
1153 * Purpose : query com port control block
1154 * Variables :
1155 * Result :
1156 * Remark :
1157 * Status :
1158 *
1159 * Author : Achim Hasenmueller
1160 *****************************************************************************/
1161BOOL HMDeviceHandler::GetCommState(PHMHANDLEDATA pHMHandleData, LPDCB lpdcb)
1162{
1163 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommState(%08xh,%08xh)\n",
1164 pHMHandleData->hHMHandle,
1165 lpdcb));
1166 SetLastError(ERROR_INVALID_HANDLE);
1167 return(FALSE);
1168}
1169
1170BOOL HMDeviceHandler::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
1171 LPDWORD lpfdwEvtMask,
1172 LPOVERLAPPED lpo)
1173{
1174 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitCommEvent(%08xh,%08xh,%08xh)\n",
1175 pHMHandleData->hHMHandle,
1176 lpfdwEvtMask,
1177 lpo));
1178 SetLastError(ERROR_INVALID_HANDLE);
1179 return(FALSE);
1180}
1181
1182BOOL HMDeviceHandler::GetCommProperties( PHMHANDLEDATA pHMHandleData,
1183 LPCOMMPROP lpcmmp)
1184{
1185 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommProperties(%08xh,%08xh)\n",
1186 pHMHandleData->hHMHandle,
1187 lpcmmp));
1188 SetLastError(ERROR_INVALID_HANDLE);
1189 return(FALSE);
1190}
1191
1192BOOL HMDeviceHandler::GetCommMask( PHMHANDLEDATA pHMHandleData,
1193 LPDWORD lpfdwEvtMask)
1194{
1195 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommMask(%08xh,%08xh)\n",
1196 pHMHandleData->hHMHandle,
1197 lpfdwEvtMask));
1198 SetLastError(ERROR_INVALID_HANDLE);
1199 return(FALSE);
1200}
1201
1202BOOL HMDeviceHandler::SetCommMask( PHMHANDLEDATA pHMHandleData,
1203 DWORD fdwEvtMask)
1204{
1205 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommMask(%08xh,%08xh)\n",
1206 pHMHandleData->hHMHandle,
1207 fdwEvtMask));
1208 SetLastError(ERROR_INVALID_HANDLE);
1209 return(FALSE);
1210}
1211
1212BOOL HMDeviceHandler::PurgeComm( PHMHANDLEDATA pHMHandleData,
1213 DWORD fdwAction)
1214{
1215 dprintf(("KERNEL32: HandleManager::DeviceHandler::PurgeComm(%08xh,%08xh)\n",
1216 pHMHandleData->hHMHandle,
1217 fdwAction));
1218 SetLastError(ERROR_INVALID_HANDLE);
1219 return(FALSE);
1220}
1221
1222BOOL HMDeviceHandler::ClearCommError( PHMHANDLEDATA pHMHandleData,
1223 LPDWORD lpdwErrors,
1224 LPCOMSTAT lpcst)
1225{
1226 dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommError(%08xh,%08xh,%08xh)\n",
1227 pHMHandleData->hHMHandle,
1228 lpdwErrors,
1229 lpcst));
1230 SetLastError(ERROR_INVALID_HANDLE);
1231 return(FALSE);
1232}
1233
1234BOOL HMDeviceHandler::SetCommState( PHMHANDLEDATA pHMHandleData,
1235 LPDCB lpdcb)
1236{
1237 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommState(%08xh,%08xh)\n",
1238 pHMHandleData->hHMHandle,
1239 lpdcb));
1240 SetLastError(ERROR_INVALID_HANDLE);
1241 return(FALSE);
1242}
1243
1244BOOL HMDeviceHandler::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
1245 LPCOMMTIMEOUTS lpctmo)
1246{
1247 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommTimeouts(%08xh,%08xh)\n",
1248 pHMHandleData->hHMHandle,
1249 lpctmo));
1250 SetLastError(ERROR_INVALID_HANDLE);
1251 return(FALSE);
1252}
1253BOOL HMDeviceHandler::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
1254 LPDWORD lpModemStat )
1255{
1256 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommModemStatus(%08xh,%08xh)\n",
1257 pHMHandleData->hHMHandle,
1258 lpModemStat));
1259 SetLastError(ERROR_INVALID_HANDLE);
1260 return(FALSE);
1261}
1262
1263BOOL HMDeviceHandler::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
1264 LPCOMMTIMEOUTS lpctmo)
1265{
1266 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommTimeouts(%08xh,%08xh)\n",
1267 pHMHandleData->hHMHandle,
1268 lpctmo));
1269 SetLastError(ERROR_INVALID_HANDLE);
1270 return(FALSE);
1271}
1272
1273BOOL HMDeviceHandler::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
1274 CHAR cChar )
1275{
1276 dprintf(("KERNEL32: HandleManager::DeviceHandler::TransmitCommChar(%08xh,%02xh)\n",
1277 pHMHandleData->hHMHandle,
1278 cChar));
1279 SetLastError(ERROR_INVALID_HANDLE);
1280 return(FALSE);
1281}
1282
1283BOOL HMDeviceHandler::SetCommConfig( PHMHANDLEDATA pHMHandleData,
1284 LPCOMMCONFIG lpCC,
1285 DWORD dwSize )
1286{
1287 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommConfig(%08xh,%08xh,%08xh)\n",
1288 pHMHandleData->hHMHandle,
1289 lpCC,
1290 dwSize));
1291 SetLastError(ERROR_INVALID_HANDLE);
1292 return(FALSE);
1293}
1294
1295BOOL HMDeviceHandler::SetCommBreak( PHMHANDLEDATA pHMHandleData )
1296{
1297 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommBreak(%08xh)\n",
1298 pHMHandleData->hHMHandle));
1299 SetLastError(ERROR_INVALID_HANDLE);
1300 return(FALSE);
1301}
1302
1303BOOL HMDeviceHandler::GetCommConfig( PHMHANDLEDATA pHMHandleData,
1304 LPCOMMCONFIG lpCC,
1305 LPDWORD lpdwSize )
1306{
1307 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommConfig(%08xh,%08xh,%08xh)\n",
1308 pHMHandleData->hHMHandle,
1309 lpCC,
1310 lpdwSize));
1311 SetLastError(ERROR_INVALID_HANDLE);
1312 return(FALSE);
1313}
1314
1315BOOL HMDeviceHandler::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
1316 UINT dwFunc )
1317{
1318 dprintf(("KERNEL32: HandleManager::DeviceHandler::EscapeCommFunction(%08xh,%08xh)\n",
1319 pHMHandleData->hHMHandle,
1320 dwFunc));
1321 SetLastError(ERROR_INVALID_HANDLE);
1322 return(FALSE);
1323}
1324
1325BOOL HMDeviceHandler::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
1326{
1327 dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommBreak(%08xh)\n",
1328 pHMHandleData->hHMHandle));
1329 SetLastError(ERROR_INVALID_HANDLE);
1330 return(FALSE);
1331}
1332
1333BOOL HMDeviceHandler::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
1334 LPCOMMCONFIG lpCC,
1335 DWORD dwSize)
1336{
1337 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
1338 pHMHandleData->hHMHandle,
1339 lpCC,
1340 dwSize));
1341 SetLastError(ERROR_INVALID_HANDLE);
1342 return(FALSE);
1343}
1344
1345BOOL HMDeviceHandler::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
1346 LPCOMMCONFIG lpCC,
1347 LPDWORD lpdwSize)
1348{
1349 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
1350 pHMHandleData->hHMHandle,
1351 lpCC,
1352 lpdwSize));
1353 SetLastError(ERROR_INVALID_HANDLE);
1354 return(FALSE);
1355}
1356
1357/*****************************************************************************
1358 * Name : DWORD HMDeviceHandler::OpenThreadToken
1359 * Purpose :
1360 * Variables :
1361 * Result :
1362 * Remark :
1363 * Status :
1364 *
1365 * Author : SvL
1366 *****************************************************************************/
1367
1368DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
1369 HANDLE ThreadHandle,
1370 BOOL OpenAsSelf)
1371{
1372 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenThreadToken(%08xh,%08xh)\n",
1373 pHMHandleData->hHMHandle,
1374 ThreadHandle));
1375
1376 return ERROR_INVALID_HANDLE;
1377}
1378
1379/*****************************************************************************
1380 * Name : DWORD HMDeviceHandler::OpenThreadToken
1381 * Purpose :
1382 * Variables :
1383 * Result :
1384 * Remark :
1385 * Status :
1386 *
1387 * Author : SvL
1388 *****************************************************************************/
1389
1390DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
1391 DWORD dwUserData,
1392 HANDLE ProcessHandle)
1393{
1394 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenProcessToken(%08xh,%08xh)\n",
1395 pHMHandleData->hHMHandle,
1396 ProcessHandle));
1397
1398 return ERROR_INVALID_HANDLE;
1399}
1400/*****************************************************************************
1401 * Name : DWORD HMDeviceHandler::CreateThread
1402 * Purpose :
1403 * Variables :
1404 * Result :
1405 * Remark :
1406 * Status :
1407 *
1408 * Author : SvL
1409 *****************************************************************************/
1410HANDLE HMDeviceHandler::CreateThread(PHMHANDLEDATA pHMHandleData,
1411 LPSECURITY_ATTRIBUTES lpsa,
1412 DWORD cbStack,
1413 LPTHREAD_START_ROUTINE lpStartAddr,
1414 LPVOID lpvThreadParm,
1415 DWORD fdwCreate,
1416 LPDWORD lpIDThread,
1417 BOOL fFirstThread)
1418{
1419 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateThread %08xh",
1420 pHMHandleData->hHMHandle));
1421
1422 return ERROR_INVALID_HANDLE;
1423}
1424/*****************************************************************************
1425 * Name : DWORD HMDeviceHandler::GetThreadPriority
1426 * Purpose :
1427 * Variables :
1428 * Result :
1429 * Remark :
1430 * Status :
1431 *
1432 * Author : SvL
1433 *****************************************************************************/
1434INT HMDeviceHandler::GetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1435{
1436 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadPriority %08xh",
1437 pHMHandleData->hHMHandle));
1438
1439 return THREAD_PRIORITY_ERROR_RETURN;
1440}
1441/*****************************************************************************
1442 * Name : DWORD HMDeviceHandler::SuspendThread
1443 * Purpose :
1444 * Variables :
1445 * Result :
1446 * Remark :
1447 * Status :
1448 *
1449 * Author : SvL
1450 *****************************************************************************/
1451DWORD HMDeviceHandler::SuspendThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1452{
1453 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SuspendThread %08xh",
1454 pHMHandleData->hHMHandle));
1455
1456 return -1;
1457}
1458/*****************************************************************************
1459 * Name : DWORD HMDeviceHandler::SetThreadPriority
1460 * Purpose :
1461 * Variables :
1462 * Result :
1463 * Remark :
1464 * Status :
1465 *
1466 * Author : SvL
1467 *****************************************************************************/
1468BOOL HMDeviceHandler::SetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData, int priority)
1469{
1470 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadPriority %08xh",
1471 pHMHandleData->hHMHandle));
1472
1473 return FALSE;
1474}
1475/*****************************************************************************
1476 * Name : DWORD HMDeviceHandler::GetThreadContext
1477 * Purpose :
1478 * Variables :
1479 * Result :
1480 * Remark :
1481 * Status :
1482 *
1483 * Author : SvL
1484 *****************************************************************************/
1485BOOL HMDeviceHandler::GetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext)
1486{
1487 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadContext %08xh",
1488 pHMHandleData->hHMHandle));
1489
1490 return FALSE;
1491}
1492/*****************************************************************************
1493 * Name : DWORD HMDeviceHandler::SetThreadContext
1494 * Purpose :
1495 * Variables :
1496 * Result :
1497 * Remark :
1498 * Status :
1499 *
1500 * Author : SvL
1501 *****************************************************************************/
1502BOOL HMDeviceHandler::SetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext)
1503{
1504 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadContext %08xh",
1505 pHMHandleData->hHMHandle));
1506
1507 return FALSE;
1508}
1509/*****************************************************************************
1510 * Name : DWORD HMDeviceHandler::TerminateThread
1511 * Purpose :
1512 * Variables :
1513 * Result :
1514 * Remark :
1515 * Status :
1516 *
1517 * Author : SvL
1518 *****************************************************************************/
1519BOOL HMDeviceHandler::TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1520{
1521 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1522 pHMHandleData->hHMHandle));
1523
1524 return FALSE;
1525}
1526/*****************************************************************************
1527 * Name : DWORD HMDeviceHandler::ResumeThread
1528 * Purpose :
1529 * Variables :
1530 * Result :
1531 * Remark :
1532 * Status :
1533 *
1534 * Author : SvL
1535 *****************************************************************************/
1536DWORD HMDeviceHandler::ResumeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1537{
1538 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1539 pHMHandleData->hHMHandle));
1540
1541 return -1;
1542}
1543/*****************************************************************************
1544 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1545 * Purpose :
1546 * Variables :
1547 * Result :
1548 * Remark :
1549 * Status :
1550 *
1551 * Author : SvL
1552 *****************************************************************************/
1553BOOL HMDeviceHandler::GetExitCodeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1554{
1555 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1556 pHMHandleData->hHMHandle));
1557
1558 return FALSE;
1559}
1560/*****************************************************************************
1561 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1562 * Purpose :
1563 * Variables :
1564 * Result :
1565 * Remark :
1566 * Status :
1567 *
1568 * Author : SvL
1569 *****************************************************************************/
1570BOOL HMDeviceHandler::SetThreadTerminated(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1571{
1572 return FALSE;
1573}
1574
1575/*****************************************************************************
1576 * Name : DWORD HMDeviceHandler::PeekNamedPipe
1577 * Purpose :
1578 * Variables :
1579 * Result :
1580 * Remark :
1581 * Status :
1582 *
1583 * Author : Przemyslaw Dobrowolski
1584 *****************************************************************************/
1585BOOL HMDeviceHandler::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
1586 LPVOID lpvBuffer,
1587 DWORD cbBuffer,
1588 LPDWORD lpcbRead,
1589 LPDWORD lpcbAvail,
1590 LPDWORD lpcbMessage)
1591{
1592 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::PeekNamedPipe (%08x)\n",
1593 pHMHandleData->hHMHandle));
1594
1595 return (FALSE);
1596}
1597
1598/*****************************************************************************
1599 * Name : DWORD HMDeviceHandler::CreateNamedPipe
1600 * Purpose :
1601 * Variables :
1602 * Result :
1603 * Remark :
1604 * Status :
1605 *
1606 * Author : Przemyslaw Dobrowolski
1607 *****************************************************************************/
1608DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
1609 LPCTSTR lpName,
1610 DWORD dwOpenMode,
1611 DWORD dwPipeMode,
1612 DWORD nMaxInstances,
1613 DWORD nOutBufferSize,
1614 DWORD nInBufferSize,
1615 DWORD nDefaultTimeOut,
1616 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1617{
1618 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateNamedPipe (%s)\n",
1619 lpName));
1620
1621 return ERROR_INVALID_HANDLE;
1622}
1623
1624/*****************************************************************************
1625 * Name : BOOL HMDeviceHandler::ConnectNamedPipe
1626 * Purpose :
1627 * Variables :
1628 * Result :
1629 * Remark :
1630 * Status :
1631 *
1632 * Author : Przemyslaw Dobrowolski
1633 *****************************************************************************/
1634BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
1635 LPOVERLAPPED lpOverlapped)
1636{
1637 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ConnectNamedPipe (%08x)\n",
1638 pHMHandleData->hHMHandle));
1639
1640 return FALSE;
1641}
1642
1643/*****************************************************************************
1644 * Name : BOOL HMDeviceHandler::DisconnectNamedPipe
1645 * Purpose :
1646 * Variables :
1647 * Result :
1648 * Remark :
1649 * Status :
1650 *
1651 * Author : Przemyslaw Dobrowolski
1652 *****************************************************************************/
1653BOOL HMDeviceHandler::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
1654{
1655 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::DisconnectNamedPipe (%08x)\n",
1656 pHMHandleData->hHMHandle));
1657
1658 return FALSE;
1659}
1660
1661/*****************************************************************************
1662 * Name : BOOL HMDeviceHandler::GetNamedPipeHandleState
1663 * Purpose :
1664 * Variables :
1665 * Result :
1666 * Remark :
1667 * Status :
1668 *
1669 * Author : Przemyslaw Dobrowolski
1670 *****************************************************************************/
1671BOOL HMDeviceHandler::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1672 LPDWORD lpState,
1673 LPDWORD lpCurInstances,
1674 LPDWORD lpMaxCollectionCount,
1675 LPDWORD lpCollectDataTimeout,
1676 LPTSTR lpUserName,
1677 DWORD nMaxUserNameSize)
1678{
1679 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeHandleState (%08x)\n",
1680 pHMHandleData->hHMHandle));
1681
1682 return FALSE;
1683}
1684
1685/*****************************************************************************
1686 * Name : BOOL HMDeviceHandler::GetNamedPipeInfo
1687 * Purpose :
1688 * Variables :
1689 * Result :
1690 * Remark :
1691 * Status :
1692 *
1693 * Author : Przemyslaw Dobrowolski
1694 *****************************************************************************/
1695BOOL HMDeviceHandler::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
1696 LPDWORD lpFlags,
1697 LPDWORD lpOutBufferSize,
1698 LPDWORD lpInBufferSize,
1699 LPDWORD lpMaxInstances)
1700{
1701 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeInfo (%08x)\n",
1702 pHMHandleData->hHMHandle));
1703
1704 return FALSE;
1705}
1706
1707/*****************************************************************************
1708 * Name : DWORD HMDeviceHandler::TransactNamedPipe
1709 * Purpose :
1710 * Variables :
1711 * Result :
1712 * Remark :
1713 * Status :
1714 *
1715 * Author : Przemyslaw Dobrowolski
1716 *****************************************************************************/
1717DWORD HMDeviceHandler::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
1718 LPVOID lpvWriteBuf,
1719 DWORD cbWriteBuf,
1720 LPVOID lpvReadBuf,
1721 DWORD cbReadBuf,
1722 LPDWORD lpcbRead,
1723 LPOVERLAPPED lpo)
1724{
1725 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TransactNamedPipe (%08x)\n",
1726 pHMHandleData->hHMHandle));
1727
1728 return FALSE;
1729}
1730
1731/*****************************************************************************
1732 * Name : BOOL HMDeviceHandler::SetNamedPipeHandleState
1733 * Purpose :
1734 * Variables :
1735 * Result :
1736 * Remark :
1737 * Status :
1738 *
1739 * Author : Przemyslaw Dobrowolski
1740 *****************************************************************************/
1741BOOL HMDeviceHandler::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1742 LPDWORD lpdwMode,
1743 LPDWORD lpcbMaxCollect,
1744 LPDWORD lpdwCollectDataTimeout)
1745{
1746 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetNamedPipeHandleState (%08x)\n",
1747 pHMHandleData->hHMHandle));
1748
1749 return FALSE;
1750}
1751
1752/*****************************************************************************
1753 * Name : BOOL HMDeviceHandler::CreatePipe
1754 * Purpose :
1755 * Variables :
1756 * Result :
1757 * Remark :
1758 * Status :
1759 *
1760 * Author : Przemyslaw Dobrowolski
1761 *****************************************************************************/
1762BOOL HMDeviceHandler::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
1763 PHMHANDLEDATA pHMHandleDataWrite,
1764 LPSECURITY_ATTRIBUTES lpsa,
1765 DWORD cbPipe)
1766{
1767 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreatePipe (%08x,%08x)\n",
1768 pHMHandleDataRead->hHMHandle,pHMHandleDataWrite->hHMHandle));
1769
1770 return(FALSE);
1771}
1772/*****************************************************************************
1773 * Name : BOOL HMDeviceHandler::GetMailslotInfo
1774 * Purpose :
1775 * Variables :
1776 * Result :
1777 * Remark :
1778 * Status :
1779 *
1780 * Author : SvL
1781 *****************************************************************************/
1782BOOL HMDeviceHandler::GetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1783 LPDWORD lpMaxMessageSize,
1784 LPDWORD lpNextSize,
1785 LPDWORD lpMessageCount,
1786 LPDWORD lpReadTimeout)
1787{
1788 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetMailslotInfo %08x",
1789 pHMHandleData->hHMHandle));
1790
1791 return(FALSE);
1792}
1793/*****************************************************************************
1794 * Name : BOOL HMDeviceHandler::SetMailslotInfo
1795 * Purpose :
1796 * Variables :
1797 * Result :
1798 * Remark :
1799 * Status :
1800 *
1801 * Author : SvL
1802 *****************************************************************************/
1803BOOL HMDeviceHandler::SetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1804 DWORD dwReadTimeout)
1805{
1806 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetMailslotInfo %08x %x",
1807 pHMHandleData->hHMHandle, dwReadTimeout));
1808
1809 return(FALSE);
1810}
1811/*****************************************************************************
1812 * Name : BOOL HMDeviceHandler::WaitForSingleObject
1813 * Purpose :
1814 * Variables :
1815 * Result :
1816 * Remark :
1817 * Status :
1818 *
1819 * Author : SvL
1820 *****************************************************************************/
1821DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
1822 DWORD dwTimeout)
1823{
1824 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObject %08x %x",
1825 pHMHandleData->hHMHandle, dwTimeout));
1826
1827 return WAIT_FAILED;
1828}
1829/*****************************************************************************
1830 * Name : BOOL HMDeviceHandler::WaitForSingleObject
1831 * Purpose :
1832 * Variables :
1833 * Result :
1834 * Remark :
1835 * Status :
1836 *
1837 * Author : SvL
1838 *****************************************************************************/
1839DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
1840 DWORD dwTimeout,
1841 BOOL fAlertable)
1842{
1843 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObjectEx %08x %x %d",
1844 pHMHandleData->hHMHandle, dwTimeout, fAlertable));
1845
1846 return WAIT_FAILED;
1847}
1848/*****************************************************************************
1849 * Name : BOOL HMDeviceHandler::MsgWaitForMultipleObjects
1850 * Purpose :
1851 * Variables :
1852 * Result :
1853 * Remark :
1854 * Status :
1855 *
1856 * Author : SvL
1857 *****************************************************************************/
1858DWORD HMDeviceHandler::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
1859 DWORD nCount,
1860 LPHANDLE pHandles,
1861 BOOL fWaitAll,
1862 DWORD dwMilliseconds,
1863 DWORD dwWakeMask)
1864{
1865 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
1866 pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
1867
1868 return WAIT_FAILED;
1869}
1870/*****************************************************************************
1871 * Name : BOOL HMDeviceHandler::WaitForMultipleObjects
1872 * Purpose :
1873 * Variables :
1874 * Result :
1875 * Remark :
1876 * Status :
1877 *
1878 * Author : SvL
1879 *****************************************************************************/
1880DWORD HMDeviceHandler::WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
1881 DWORD cObjects,
1882 PHANDLE lphObjects,
1883 BOOL fWaitAll,
1884 DWORD dwTimeout)
1885{
1886 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
1887 pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
1888
1889 return WAIT_FAILED;
1890}
Note: See TracBrowser for help on using the repository browser.