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

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

Support DuplicateHandle for threads; cleaned up semaphore code
File size: 65.0 KB
Line 
1/* $Id: hmdevice.cpp,v 1.34 2003-02-04 11:28:56 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(HANDLE srchandle, 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::SetThreadContext
1511 * Purpose :
1512 * Variables :
1513 * Result :
1514 * Remark :
1515 * Status :
1516 *
1517 * Author : SvL
1518 *****************************************************************************/
1519BOOL HMDeviceHandler::GetThreadTimes(HANDLE hThread,
1520 PHMHANDLEDATA pHMHandleData,
1521 LPFILETIME lpCreationTime,
1522 LPFILETIME lpExitTime,
1523 LPFILETIME lpKernelTime,
1524 LPFILETIME lpUserTime)
1525{
1526 dprintf(("Kernel32: ERROR: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
1527 hThread,
1528 lpCreationTime,
1529 lpExitTime,
1530 lpKernelTime,
1531 lpUserTime));
1532
1533 return FALSE;
1534}
1535
1536/*****************************************************************************
1537 * Name : DWORD HMDeviceHandler::TerminateThread
1538 * Purpose :
1539 * Variables :
1540 * Result :
1541 * Remark :
1542 * Status :
1543 *
1544 * Author : SvL
1545 *****************************************************************************/
1546BOOL HMDeviceHandler::TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1547{
1548 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1549 pHMHandleData->hHMHandle));
1550
1551 return FALSE;
1552}
1553/*****************************************************************************
1554 * Name : DWORD HMDeviceHandler::ResumeThread
1555 * Purpose :
1556 * Variables :
1557 * Result :
1558 * Remark :
1559 * Status :
1560 *
1561 * Author : SvL
1562 *****************************************************************************/
1563DWORD HMDeviceHandler::ResumeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1564{
1565 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1566 pHMHandleData->hHMHandle));
1567
1568 return -1;
1569}
1570/*****************************************************************************
1571 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1572 * Purpose :
1573 * Variables :
1574 * Result :
1575 * Remark :
1576 * Status :
1577 *
1578 * Author : SvL
1579 *****************************************************************************/
1580BOOL HMDeviceHandler::GetExitCodeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1581{
1582 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1583 pHMHandleData->hHMHandle));
1584
1585 return FALSE;
1586}
1587/*****************************************************************************
1588 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1589 * Purpose :
1590 * Variables :
1591 * Result :
1592 * Remark :
1593 * Status :
1594 *
1595 * Author : SvL
1596 *****************************************************************************/
1597BOOL HMDeviceHandler::SetThreadTerminated(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1598{
1599 return FALSE;
1600}
1601
1602/*****************************************************************************
1603 * Name : DWORD HMDeviceHandler::PeekNamedPipe
1604 * Purpose :
1605 * Variables :
1606 * Result :
1607 * Remark :
1608 * Status :
1609 *
1610 * Author : Przemyslaw Dobrowolski
1611 *****************************************************************************/
1612BOOL HMDeviceHandler::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
1613 LPVOID lpvBuffer,
1614 DWORD cbBuffer,
1615 LPDWORD lpcbRead,
1616 LPDWORD lpcbAvail,
1617 LPDWORD lpcbMessage)
1618{
1619 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::PeekNamedPipe (%08x)\n",
1620 pHMHandleData->hHMHandle));
1621
1622 return (FALSE);
1623}
1624
1625/*****************************************************************************
1626 * Name : DWORD HMDeviceHandler::CreateNamedPipe
1627 * Purpose :
1628 * Variables :
1629 * Result :
1630 * Remark :
1631 * Status :
1632 *
1633 * Author : Przemyslaw Dobrowolski
1634 *****************************************************************************/
1635DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
1636 LPCTSTR lpName,
1637 DWORD dwOpenMode,
1638 DWORD dwPipeMode,
1639 DWORD nMaxInstances,
1640 DWORD nOutBufferSize,
1641 DWORD nInBufferSize,
1642 DWORD nDefaultTimeOut,
1643 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1644{
1645 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateNamedPipe (%s)\n",
1646 lpName));
1647
1648 return ERROR_INVALID_HANDLE;
1649}
1650
1651/*****************************************************************************
1652 * Name : BOOL HMDeviceHandler::ConnectNamedPipe
1653 * Purpose :
1654 * Variables :
1655 * Result :
1656 * Remark :
1657 * Status :
1658 *
1659 * Author : Przemyslaw Dobrowolski
1660 *****************************************************************************/
1661BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
1662 LPOVERLAPPED lpOverlapped)
1663{
1664 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ConnectNamedPipe (%08x)\n",
1665 pHMHandleData->hHMHandle));
1666
1667 return FALSE;
1668}
1669
1670/*****************************************************************************
1671 * Name : BOOL HMDeviceHandler::DisconnectNamedPipe
1672 * Purpose :
1673 * Variables :
1674 * Result :
1675 * Remark :
1676 * Status :
1677 *
1678 * Author : Przemyslaw Dobrowolski
1679 *****************************************************************************/
1680BOOL HMDeviceHandler::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
1681{
1682 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::DisconnectNamedPipe (%08x)\n",
1683 pHMHandleData->hHMHandle));
1684
1685 return FALSE;
1686}
1687
1688/*****************************************************************************
1689 * Name : BOOL HMDeviceHandler::GetNamedPipeHandleState
1690 * Purpose :
1691 * Variables :
1692 * Result :
1693 * Remark :
1694 * Status :
1695 *
1696 * Author : Przemyslaw Dobrowolski
1697 *****************************************************************************/
1698BOOL HMDeviceHandler::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1699 LPDWORD lpState,
1700 LPDWORD lpCurInstances,
1701 LPDWORD lpMaxCollectionCount,
1702 LPDWORD lpCollectDataTimeout,
1703 LPTSTR lpUserName,
1704 DWORD nMaxUserNameSize)
1705{
1706 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeHandleState (%08x)\n",
1707 pHMHandleData->hHMHandle));
1708
1709 return FALSE;
1710}
1711
1712/*****************************************************************************
1713 * Name : BOOL HMDeviceHandler::GetNamedPipeInfo
1714 * Purpose :
1715 * Variables :
1716 * Result :
1717 * Remark :
1718 * Status :
1719 *
1720 * Author : Przemyslaw Dobrowolski
1721 *****************************************************************************/
1722BOOL HMDeviceHandler::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
1723 LPDWORD lpFlags,
1724 LPDWORD lpOutBufferSize,
1725 LPDWORD lpInBufferSize,
1726 LPDWORD lpMaxInstances)
1727{
1728 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeInfo (%08x)\n",
1729 pHMHandleData->hHMHandle));
1730
1731 return FALSE;
1732}
1733
1734/*****************************************************************************
1735 * Name : DWORD HMDeviceHandler::TransactNamedPipe
1736 * Purpose :
1737 * Variables :
1738 * Result :
1739 * Remark :
1740 * Status :
1741 *
1742 * Author : Przemyslaw Dobrowolski
1743 *****************************************************************************/
1744DWORD HMDeviceHandler::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
1745 LPVOID lpvWriteBuf,
1746 DWORD cbWriteBuf,
1747 LPVOID lpvReadBuf,
1748 DWORD cbReadBuf,
1749 LPDWORD lpcbRead,
1750 LPOVERLAPPED lpo)
1751{
1752 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TransactNamedPipe (%08x)\n",
1753 pHMHandleData->hHMHandle));
1754
1755 return FALSE;
1756}
1757
1758/*****************************************************************************
1759 * Name : BOOL HMDeviceHandler::SetNamedPipeHandleState
1760 * Purpose :
1761 * Variables :
1762 * Result :
1763 * Remark :
1764 * Status :
1765 *
1766 * Author : Przemyslaw Dobrowolski
1767 *****************************************************************************/
1768BOOL HMDeviceHandler::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1769 LPDWORD lpdwMode,
1770 LPDWORD lpcbMaxCollect,
1771 LPDWORD lpdwCollectDataTimeout)
1772{
1773 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetNamedPipeHandleState (%08x)\n",
1774 pHMHandleData->hHMHandle));
1775
1776 return FALSE;
1777}
1778
1779/*****************************************************************************
1780 * Name : BOOL HMDeviceHandler::CreatePipe
1781 * Purpose :
1782 * Variables :
1783 * Result :
1784 * Remark :
1785 * Status :
1786 *
1787 * Author : Przemyslaw Dobrowolski
1788 *****************************************************************************/
1789BOOL HMDeviceHandler::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
1790 PHMHANDLEDATA pHMHandleDataWrite,
1791 LPSECURITY_ATTRIBUTES lpsa,
1792 DWORD cbPipe)
1793{
1794 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreatePipe (%08x,%08x)\n",
1795 pHMHandleDataRead->hHMHandle,pHMHandleDataWrite->hHMHandle));
1796
1797 return(FALSE);
1798}
1799/*****************************************************************************
1800 * Name : BOOL HMDeviceHandler::GetMailslotInfo
1801 * Purpose :
1802 * Variables :
1803 * Result :
1804 * Remark :
1805 * Status :
1806 *
1807 * Author : SvL
1808 *****************************************************************************/
1809BOOL HMDeviceHandler::GetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1810 LPDWORD lpMaxMessageSize,
1811 LPDWORD lpNextSize,
1812 LPDWORD lpMessageCount,
1813 LPDWORD lpReadTimeout)
1814{
1815 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetMailslotInfo %08x",
1816 pHMHandleData->hHMHandle));
1817
1818 return(FALSE);
1819}
1820/*****************************************************************************
1821 * Name : BOOL HMDeviceHandler::SetMailslotInfo
1822 * Purpose :
1823 * Variables :
1824 * Result :
1825 * Remark :
1826 * Status :
1827 *
1828 * Author : SvL
1829 *****************************************************************************/
1830BOOL HMDeviceHandler::SetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1831 DWORD dwReadTimeout)
1832{
1833 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetMailslotInfo %08x %x",
1834 pHMHandleData->hHMHandle, dwReadTimeout));
1835
1836 return(FALSE);
1837}
1838/*****************************************************************************
1839 * Name : BOOL HMDeviceHandler::WaitForSingleObject
1840 * Purpose :
1841 * Variables :
1842 * Result :
1843 * Remark :
1844 * Status :
1845 *
1846 * Author : SvL
1847 *****************************************************************************/
1848DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
1849 DWORD dwTimeout)
1850{
1851 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObject %08x %x",
1852 pHMHandleData->hHMHandle, dwTimeout));
1853
1854 return WAIT_FAILED;
1855}
1856/*****************************************************************************
1857 * Name : BOOL HMDeviceHandler::WaitForSingleObject
1858 * Purpose :
1859 * Variables :
1860 * Result :
1861 * Remark :
1862 * Status :
1863 *
1864 * Author : SvL
1865 *****************************************************************************/
1866DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
1867 DWORD dwTimeout,
1868 BOOL fAlertable)
1869{
1870 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObjectEx %08x %x %d",
1871 pHMHandleData->hHMHandle, dwTimeout, fAlertable));
1872
1873 return WAIT_FAILED;
1874}
1875/*****************************************************************************
1876 * Name : BOOL HMDeviceHandler::MsgWaitForMultipleObjects
1877 * Purpose :
1878 * Variables :
1879 * Result :
1880 * Remark :
1881 * Status :
1882 *
1883 * Author : SvL
1884 *****************************************************************************/
1885DWORD HMDeviceHandler::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
1886 DWORD nCount,
1887 LPHANDLE pHandles,
1888 BOOL fWaitAll,
1889 DWORD dwMilliseconds,
1890 DWORD dwWakeMask)
1891{
1892 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
1893 pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
1894
1895 return WAIT_FAILED;
1896}
1897/*****************************************************************************
1898 * Name : BOOL HMDeviceHandler::WaitForMultipleObjects
1899 * Purpose :
1900 * Variables :
1901 * Result :
1902 * Remark :
1903 * Status :
1904 *
1905 * Author : SvL
1906 *****************************************************************************/
1907DWORD HMDeviceHandler::WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
1908 DWORD cObjects,
1909 PHANDLE lphObjects,
1910 BOOL fWaitAll,
1911 DWORD dwTimeout)
1912{
1913 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
1914 pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
1915
1916 return WAIT_FAILED;
1917}
Note: See TracBrowser for help on using the repository browser.