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

Last change on this file since 10268 was 10132, checked in by sandervl, 22 years ago

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