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

Last change on this file since 22018 was 21302, checked in by ydario, 16 years ago

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