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

Last change on this file since 7462 was 7457, checked in by sandervl, 24 years ago

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