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

Last change on this file since 8001 was 7549, checked in by sandervl, 24 years ago

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