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

Last change on this file since 5013 was 5011, checked in by sandervl, 25 years ago

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