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

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

Handlemanager fix (MN), changes for device name lookup, com bugfix (error check) + com class now called for COMx: names
File size: 63.2 KB
Line 
1/* $Id: hmdevice.cpp,v 1.24 2000-11-14 14:27: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 (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 HFILE *hOldMap) // if create an existing memmap, return handle of old one
1111{
1112 dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
1113 pHMHandleData->hHMHandle,
1114 hFile,
1115 lpFileMappingAttributes,
1116 flProtect,
1117 dwMaximumSizeHigh,
1118 dwMaximumSizeLow,
1119 lpName));
1120
1121 return(ERROR_INVALID_FUNCTION);
1122}
1123
1124
1125/*****************************************************************************
1126 * Name : DWORD HMDeviceHandler::OpenFileMapping
1127 * Purpose : open memory mapped file
1128 * Parameters: PHMHANDLEDATA pHMHandleData
1129 * LPOVERLAPPED arg2
1130 * LPDWORD arg3
1131 * BOOL arg4
1132 * Variables :
1133 * Result : API returncode
1134 * Remark :
1135 * Status :
1136 *
1137 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1138 *****************************************************************************/
1139
1140DWORD HMDeviceHandler::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
1141 DWORD fdwAccess,
1142 BOOL fInherit,
1143 LPCTSTR lpName)
1144{
1145 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
1146 pHMHandleData->hHMHandle,
1147 fdwAccess,
1148 fInherit,
1149 lpName));
1150
1151 return(ERROR_INVALID_FUNCTION);
1152}
1153
1154/*****************************************************************************
1155 * Name : DWORD HMDeviceHandler::MapViewOfFile
1156 * Purpose : map memory mapped file
1157 * Parameters: PHMHANDLEDATA pHMHandleData
1158 * DWORD dwDesiredAccess,
1159 * DWORD dwFileOffsetHigh,
1160 * DWORD dwFileOffsetLow,
1161 * DWORD dwNumberOfBytesToMap
1162 * Variables :
1163 * Result : address to memory mapped region
1164 * Remark :
1165 * Status :
1166 *
1167 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1168 *****************************************************************************/
1169
1170LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
1171 DWORD dwDesiredAccess,
1172 DWORD dwFileOffsetHigh,
1173 DWORD dwFileOffsetLow,
1174 DWORD dwNumberOfBytesToMap,
1175 LPVOID lpBaseAddress)
1176{
1177 dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1178 pHMHandleData->hHMHandle,
1179 dwDesiredAccess,
1180 dwFileOffsetHigh,
1181 dwFileOffsetLow,
1182 dwNumberOfBytesToMap, lpBaseAddress));
1183
1184 return(NULL);
1185}
1186
1187/*****************************************************************************
1188 * Name : DWORD HMDeviceHandler::DeviceIoControl
1189 * Purpose : send command to device driver
1190 * Variables :
1191 * Result :
1192 * Remark :
1193 * Status :
1194 *
1195 * Author : Sander van Leeuwen
1196 *****************************************************************************/
1197
1198BOOL HMDeviceHandler::DeviceIoControl(PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
1199 LPVOID lpInBuffer, DWORD nInBufferSize,
1200 LPVOID lpOutBuffer, DWORD nOutBufferSize,
1201 LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped)
1202{
1203 dprintf(("KERNEL32: HandleManager::DeviceHandler::DeviceIoControl(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1204 pHMHandleData->hHMHandle,
1205 dwIoControlCode,
1206 lpInBuffer,
1207 nInBufferSize,
1208 lpOutBuffer, nOutBufferSize));
1209
1210 return(FALSE);
1211}
1212
1213
1214/*****************************************************************************
1215 * Name : DWORD HMDeviceHandler::SetupComm
1216 * Purpose : set com port parameters (queue)
1217 * Variables :
1218 * Result :
1219 * Remark :
1220 * Status :
1221 *
1222 * Author : Achim Hasenmueller
1223 *****************************************************************************/
1224
1225BOOL HMDeviceHandler::SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue)
1226{
1227 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetupComm(%08xh,%08xh,%08xh)\n",
1228 pHMHandleData->hHMHandle,
1229 dwInQueue, dwOutQueue));
1230 SetLastError(ERROR_INVALID_HANDLE);
1231 return(FALSE);
1232}
1233
1234
1235/*****************************************************************************
1236 * Name : DWORD HMDeviceHandler::GetCommState
1237 * Purpose : query com port control block
1238 * Variables :
1239 * Result :
1240 * Remark :
1241 * Status :
1242 *
1243 * Author : Achim Hasenmueller
1244 *****************************************************************************/
1245BOOL HMDeviceHandler::GetCommState(PHMHANDLEDATA pHMHandleData, LPDCB lpdcb)
1246{
1247 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommState(%08xh,%08xh)\n",
1248 pHMHandleData->hHMHandle,
1249 lpdcb));
1250 SetLastError(ERROR_INVALID_HANDLE);
1251 return(FALSE);
1252}
1253
1254BOOL HMDeviceHandler::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
1255 LPDWORD lpfdwEvtMask,
1256 LPOVERLAPPED lpo)
1257{
1258 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitCommEvent(%08xh,%08xh,%08xh)\n",
1259 pHMHandleData->hHMHandle,
1260 lpfdwEvtMask,
1261 lpo));
1262 SetLastError(ERROR_INVALID_HANDLE);
1263 return(FALSE);
1264}
1265
1266BOOL HMDeviceHandler::GetCommProperties( PHMHANDLEDATA pHMHandleData,
1267 LPCOMMPROP lpcmmp)
1268{
1269 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommProperties(%08xh,%08xh)\n",
1270 pHMHandleData->hHMHandle,
1271 lpcmmp));
1272 SetLastError(ERROR_INVALID_HANDLE);
1273 return(FALSE);
1274}
1275
1276BOOL HMDeviceHandler::GetCommMask( PHMHANDLEDATA pHMHandleData,
1277 LPDWORD lpfdwEvtMask)
1278{
1279 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommMask(%08xh,%08xh)\n",
1280 pHMHandleData->hHMHandle,
1281 lpfdwEvtMask));
1282 SetLastError(ERROR_INVALID_HANDLE);
1283 return(FALSE);
1284}
1285
1286BOOL HMDeviceHandler::SetCommMask( PHMHANDLEDATA pHMHandleData,
1287 DWORD fdwEvtMask)
1288{
1289 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommMask(%08xh,%08xh)\n",
1290 pHMHandleData->hHMHandle,
1291 fdwEvtMask));
1292 SetLastError(ERROR_INVALID_HANDLE);
1293 return(FALSE);
1294}
1295
1296BOOL HMDeviceHandler::PurgeComm( PHMHANDLEDATA pHMHandleData,
1297 DWORD fdwAction)
1298{
1299 dprintf(("KERNEL32: HandleManager::DeviceHandler::PurgeComm(%08xh,%08xh)\n",
1300 pHMHandleData->hHMHandle,
1301 fdwAction));
1302 SetLastError(ERROR_INVALID_HANDLE);
1303 return(FALSE);
1304}
1305
1306BOOL HMDeviceHandler::ClearCommError( PHMHANDLEDATA pHMHandleData,
1307 LPDWORD lpdwErrors,
1308 LPCOMSTAT lpcst)
1309{
1310 dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommError(%08xh,%08xh,%08xh)\n",
1311 pHMHandleData->hHMHandle,
1312 lpdwErrors,
1313 lpcst));
1314 SetLastError(ERROR_INVALID_HANDLE);
1315 return(FALSE);
1316}
1317
1318BOOL HMDeviceHandler::SetCommState( PHMHANDLEDATA pHMHandleData,
1319 LPDCB lpdcb)
1320{
1321 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommState(%08xh,%08xh)\n",
1322 pHMHandleData->hHMHandle,
1323 lpdcb));
1324 SetLastError(ERROR_INVALID_HANDLE);
1325 return(FALSE);
1326}
1327
1328BOOL HMDeviceHandler::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
1329 LPCOMMTIMEOUTS lpctmo)
1330{
1331 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommTimeouts(%08xh,%08xh)\n",
1332 pHMHandleData->hHMHandle,
1333 lpctmo));
1334 SetLastError(ERROR_INVALID_HANDLE);
1335 return(FALSE);
1336}
1337BOOL HMDeviceHandler::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
1338 LPDWORD lpModemStat )
1339{
1340 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommModemStatus(%08xh,%08xh)\n",
1341 pHMHandleData->hHMHandle,
1342 lpModemStat));
1343 SetLastError(ERROR_INVALID_HANDLE);
1344 return(FALSE);
1345}
1346
1347BOOL HMDeviceHandler::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
1348 LPCOMMTIMEOUTS lpctmo)
1349{
1350 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommTimeouts(%08xh,%08xh)\n",
1351 pHMHandleData->hHMHandle,
1352 lpctmo));
1353 SetLastError(ERROR_INVALID_HANDLE);
1354 return(FALSE);
1355}
1356
1357BOOL HMDeviceHandler::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
1358 CHAR cChar )
1359{
1360 dprintf(("KERNEL32: HandleManager::DeviceHandler::TransmitCommChar(%08xh,%02xh)\n",
1361 pHMHandleData->hHMHandle,
1362 cChar));
1363 SetLastError(ERROR_INVALID_HANDLE);
1364 return(FALSE);
1365}
1366
1367BOOL HMDeviceHandler::SetCommConfig( PHMHANDLEDATA pHMHandleData,
1368 LPCOMMCONFIG lpCC,
1369 DWORD dwSize )
1370{
1371 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommConfig(%08xh,%08xh,%08xh)\n",
1372 pHMHandleData->hHMHandle,
1373 lpCC,
1374 dwSize));
1375 SetLastError(ERROR_INVALID_HANDLE);
1376 return(FALSE);
1377}
1378
1379BOOL HMDeviceHandler::SetCommBreak( PHMHANDLEDATA pHMHandleData )
1380{
1381 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommBreak(%08xh)\n",
1382 pHMHandleData->hHMHandle));
1383 SetLastError(ERROR_INVALID_HANDLE);
1384 return(FALSE);
1385}
1386
1387BOOL HMDeviceHandler::GetCommConfig( PHMHANDLEDATA pHMHandleData,
1388 LPCOMMCONFIG lpCC,
1389 LPDWORD lpdwSize )
1390{
1391 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommConfig(%08xh,%08xh,%08xh)\n",
1392 pHMHandleData->hHMHandle,
1393 lpCC,
1394 lpdwSize));
1395 SetLastError(ERROR_INVALID_HANDLE);
1396 return(FALSE);
1397}
1398
1399BOOL HMDeviceHandler::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
1400 UINT dwFunc )
1401{
1402 dprintf(("KERNEL32: HandleManager::DeviceHandler::EscapeCommFunction(%08xh,%08xh)\n",
1403 pHMHandleData->hHMHandle,
1404 dwFunc));
1405 SetLastError(ERROR_INVALID_HANDLE);
1406 return(FALSE);
1407}
1408
1409BOOL HMDeviceHandler::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
1410{
1411 dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommBreak(%08xh)\n",
1412 pHMHandleData->hHMHandle));
1413 SetLastError(ERROR_INVALID_HANDLE);
1414 return(FALSE);
1415}
1416
1417BOOL HMDeviceHandler::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
1418 LPCOMMCONFIG lpCC,
1419 DWORD dwSize)
1420{
1421 dprintf(("KERNEL32: HandleManager::DeviceHandler::SetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
1422 pHMHandleData->hHMHandle,
1423 lpCC,
1424 dwSize));
1425 SetLastError(ERROR_INVALID_HANDLE);
1426 return(FALSE);
1427}
1428
1429BOOL HMDeviceHandler::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
1430 LPCOMMCONFIG lpCC,
1431 LPDWORD lpdwSize)
1432{
1433 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
1434 pHMHandleData->hHMHandle,
1435 lpCC,
1436 lpdwSize));
1437 SetLastError(ERROR_INVALID_HANDLE);
1438 return(FALSE);
1439}
1440
1441/*****************************************************************************
1442 * Name : DWORD HMDeviceHandler::OpenThreadToken
1443 * Purpose :
1444 * Variables :
1445 * Result :
1446 * Remark :
1447 * Status :
1448 *
1449 * Author : SvL
1450 *****************************************************************************/
1451
1452DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
1453 HANDLE ThreadHandle,
1454 BOOL OpenAsSelf)
1455{
1456 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenThreadToken(%08xh,%08xh)\n",
1457 pHMHandleData->hHMHandle,
1458 ThreadHandle));
1459
1460 return ERROR_INVALID_HANDLE;
1461}
1462
1463/*****************************************************************************
1464 * Name : DWORD HMDeviceHandler::OpenThreadToken
1465 * Purpose :
1466 * Variables :
1467 * Result :
1468 * Remark :
1469 * Status :
1470 *
1471 * Author : SvL
1472 *****************************************************************************/
1473
1474DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
1475 DWORD dwUserData,
1476 HANDLE ProcessHandle)
1477{
1478 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenProcessToken(%08xh,%08xh)\n",
1479 pHMHandleData->hHMHandle,
1480 ProcessHandle));
1481
1482 return ERROR_INVALID_HANDLE;
1483}
1484/*****************************************************************************
1485 * Name : DWORD HMDeviceHandler::CreateThread
1486 * Purpose :
1487 * Variables :
1488 * Result :
1489 * Remark :
1490 * Status :
1491 *
1492 * Author : SvL
1493 *****************************************************************************/
1494HANDLE HMDeviceHandler::CreateThread(PHMHANDLEDATA pHMHandleData,
1495 LPSECURITY_ATTRIBUTES lpsa,
1496 DWORD cbStack,
1497 LPTHREAD_START_ROUTINE lpStartAddr,
1498 LPVOID lpvThreadParm,
1499 DWORD fdwCreate,
1500 LPDWORD lpIDThread,
1501 BOOL fFirstThread)
1502{
1503 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateThread %08xh",
1504 pHMHandleData->hHMHandle));
1505
1506 return ERROR_INVALID_HANDLE;
1507}
1508/*****************************************************************************
1509 * Name : DWORD HMDeviceHandler::GetThreadPriority
1510 * Purpose :
1511 * Variables :
1512 * Result :
1513 * Remark :
1514 * Status :
1515 *
1516 * Author : SvL
1517 *****************************************************************************/
1518INT HMDeviceHandler::GetThreadPriority(PHMHANDLEDATA pHMHandleData)
1519{
1520 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadPriority %08xh",
1521 pHMHandleData->hHMHandle));
1522
1523 return ERROR_INVALID_HANDLE;
1524}
1525/*****************************************************************************
1526 * Name : DWORD HMDeviceHandler::SuspendThread
1527 * Purpose :
1528 * Variables :
1529 * Result :
1530 * Remark :
1531 * Status :
1532 *
1533 * Author : SvL
1534 *****************************************************************************/
1535DWORD HMDeviceHandler::SuspendThread(PHMHANDLEDATA pHMHandleData)
1536{
1537 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SuspendThread %08xh",
1538 pHMHandleData->hHMHandle));
1539
1540 return ERROR_INVALID_HANDLE;
1541}
1542/*****************************************************************************
1543 * Name : DWORD HMDeviceHandler::SetThreadPriority
1544 * Purpose :
1545 * Variables :
1546 * Result :
1547 * Remark :
1548 * Status :
1549 *
1550 * Author : SvL
1551 *****************************************************************************/
1552BOOL HMDeviceHandler::SetThreadPriority(PHMHANDLEDATA pHMHandleData, int priority)
1553{
1554 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadPriority %08xh",
1555 pHMHandleData->hHMHandle));
1556
1557 return ERROR_INVALID_HANDLE;
1558}
1559/*****************************************************************************
1560 * Name : DWORD HMDeviceHandler::GetThreadContext
1561 * Purpose :
1562 * Variables :
1563 * Result :
1564 * Remark :
1565 * Status :
1566 *
1567 * Author : SvL
1568 *****************************************************************************/
1569BOOL HMDeviceHandler::GetThreadContext(PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext)
1570{
1571 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadContext %08xh",
1572 pHMHandleData->hHMHandle));
1573
1574 return ERROR_INVALID_HANDLE;
1575}
1576/*****************************************************************************
1577 * Name : DWORD HMDeviceHandler::SetThreadContext
1578 * Purpose :
1579 * Variables :
1580 * Result :
1581 * Remark :
1582 * Status :
1583 *
1584 * Author : SvL
1585 *****************************************************************************/
1586BOOL HMDeviceHandler::SetThreadContext(PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext)
1587{
1588 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadContext %08xh",
1589 pHMHandleData->hHMHandle));
1590
1591 return ERROR_INVALID_HANDLE;
1592}
1593/*****************************************************************************
1594 * Name : DWORD HMDeviceHandler::TerminateThread
1595 * Purpose :
1596 * Variables :
1597 * Result :
1598 * Remark :
1599 * Status :
1600 *
1601 * Author : SvL
1602 *****************************************************************************/
1603BOOL HMDeviceHandler::TerminateThread(PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1604{
1605 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1606 pHMHandleData->hHMHandle));
1607
1608 return ERROR_INVALID_HANDLE;
1609}
1610/*****************************************************************************
1611 * Name : DWORD HMDeviceHandler::ResumeThread
1612 * Purpose :
1613 * Variables :
1614 * Result :
1615 * Remark :
1616 * Status :
1617 *
1618 * Author : SvL
1619 *****************************************************************************/
1620DWORD HMDeviceHandler::ResumeThread(PHMHANDLEDATA pHMHandleData)
1621{
1622 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1623 pHMHandleData->hHMHandle));
1624
1625 return ERROR_INVALID_HANDLE;
1626}
1627/*****************************************************************************
1628 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1629 * Purpose :
1630 * Variables :
1631 * Result :
1632 * Remark :
1633 * Status :
1634 *
1635 * Author : SvL
1636 *****************************************************************************/
1637BOOL HMDeviceHandler::GetExitCodeThread(PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1638{
1639 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1640 pHMHandleData->hHMHandle));
1641
1642 return ERROR_INVALID_HANDLE;
1643}
1644/*****************************************************************************
1645 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1646 * Purpose :
1647 * Variables :
1648 * Result :
1649 * Remark :
1650 * Status :
1651 *
1652 * Author : SvL
1653 *****************************************************************************/
1654BOOL HMDeviceHandler::SetThreadTerminated(PHMHANDLEDATA pHMHandleData)
1655{
1656 return FALSE;
1657}
1658
1659/*****************************************************************************
1660 * Name : DWORD HMDeviceHandler::PeekNamedPipe
1661 * Purpose :
1662 * Variables :
1663 * Result :
1664 * Remark :
1665 * Status :
1666 *
1667 * Author : Przemyslaw Dobrowolski
1668 *****************************************************************************/
1669BOOL HMDeviceHandler::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
1670 LPVOID lpvBuffer,
1671 DWORD cbBuffer,
1672 LPDWORD lpcbRead,
1673 LPDWORD lpcbAvail,
1674 LPDWORD lpcbMessage)
1675{
1676 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::PeekNamedPipe (%08x)\n",
1677 pHMHandleData->hHMHandle));
1678
1679 return (FALSE);
1680}
1681
1682/*****************************************************************************
1683 * Name : DWORD HMDeviceHandler::CreateNamedPipe
1684 * Purpose :
1685 * Variables :
1686 * Result :
1687 * Remark :
1688 * Status :
1689 *
1690 * Author : Przemyslaw Dobrowolski
1691 *****************************************************************************/
1692DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
1693 LPCTSTR lpName,
1694 DWORD dwOpenMode,
1695 DWORD dwPipeMode,
1696 DWORD nMaxInstances,
1697 DWORD nOutBufferSize,
1698 DWORD nInBufferSize,
1699 DWORD nDefaultTimeOut,
1700 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1701{
1702 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateNamedPipe (%s)\n",
1703 lpName));
1704
1705 return ERROR_INVALID_HANDLE;
1706}
1707
1708/*****************************************************************************
1709 * Name : BOOL HMDeviceHandler::ConnectNamedPipe
1710 * Purpose :
1711 * Variables :
1712 * Result :
1713 * Remark :
1714 * Status :
1715 *
1716 * Author : Przemyslaw Dobrowolski
1717 *****************************************************************************/
1718BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
1719 LPOVERLAPPED lpOverlapped)
1720{
1721 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ConnectNamedPipe (%08x)\n",
1722 pHMHandleData->hHMHandle));
1723
1724 return FALSE;
1725}
1726
1727/*****************************************************************************
1728 * Name : BOOL HMDeviceHandler::DisconnectNamedPipe
1729 * Purpose :
1730 * Variables :
1731 * Result :
1732 * Remark :
1733 * Status :
1734 *
1735 * Author : Przemyslaw Dobrowolski
1736 *****************************************************************************/
1737BOOL HMDeviceHandler::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
1738{
1739 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::DisconnectNamedPipe (%08x)\n",
1740 pHMHandleData->hHMHandle));
1741
1742 return FALSE;
1743}
1744
1745/*****************************************************************************
1746 * Name : BOOL HMDeviceHandler::GetNamedPipeHandleState
1747 * Purpose :
1748 * Variables :
1749 * Result :
1750 * Remark :
1751 * Status :
1752 *
1753 * Author : Przemyslaw Dobrowolski
1754 *****************************************************************************/
1755BOOL HMDeviceHandler::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1756 LPDWORD lpState,
1757 LPDWORD lpCurInstances,
1758 LPDWORD lpMaxCollectionCount,
1759 LPDWORD lpCollectDataTimeout,
1760 LPTSTR lpUserName,
1761 DWORD nMaxUserNameSize)
1762{
1763 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeHandleState (%08x)\n",
1764 pHMHandleData->hHMHandle));
1765
1766 return FALSE;
1767}
1768
1769/*****************************************************************************
1770 * Name : BOOL HMDeviceHandler::GetNamedPipeInfo
1771 * Purpose :
1772 * Variables :
1773 * Result :
1774 * Remark :
1775 * Status :
1776 *
1777 * Author : Przemyslaw Dobrowolski
1778 *****************************************************************************/
1779BOOL HMDeviceHandler::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
1780 LPDWORD lpFlags,
1781 LPDWORD lpOutBufferSize,
1782 LPDWORD lpInBufferSize,
1783 LPDWORD lpMaxInstances)
1784{
1785 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeInfo (%08x)\n",
1786 pHMHandleData->hHMHandle));
1787
1788 return FALSE;
1789}
1790
1791/*****************************************************************************
1792 * Name : DWORD HMDeviceHandler::TransactNamedPipe
1793 * Purpose :
1794 * Variables :
1795 * Result :
1796 * Remark :
1797 * Status :
1798 *
1799 * Author : Przemyslaw Dobrowolski
1800 *****************************************************************************/
1801DWORD HMDeviceHandler::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
1802 LPVOID lpvWriteBuf,
1803 DWORD cbWriteBuf,
1804 LPVOID lpvReadBuf,
1805 DWORD cbReadBuf,
1806 LPDWORD lpcbRead,
1807 LPOVERLAPPED lpo)
1808{
1809 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TransactNamedPipe (%08x)\n",
1810 pHMHandleData->hHMHandle));
1811
1812 return FALSE;
1813}
1814
1815/*****************************************************************************
1816 * Name : BOOL HMDeviceHandler::SetNamedPipeHandleState
1817 * Purpose :
1818 * Variables :
1819 * Result :
1820 * Remark :
1821 * Status :
1822 *
1823 * Author : Przemyslaw Dobrowolski
1824 *****************************************************************************/
1825BOOL HMDeviceHandler::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1826 LPDWORD lpdwMode,
1827 LPDWORD lpcbMaxCollect,
1828 LPDWORD lpdwCollectDataTimeout)
1829{
1830 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetNamedPipeHandleState (%08x)\n",
1831 pHMHandleData->hHMHandle));
1832
1833 return FALSE;
1834}
1835
1836/*****************************************************************************
1837 * Name : BOOL HMDeviceHandler::CreatePipe
1838 * Purpose :
1839 * Variables :
1840 * Result :
1841 * Remark :
1842 * Status :
1843 *
1844 * Author : Przemyslaw Dobrowolski
1845 *****************************************************************************/
1846BOOL HMDeviceHandler::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
1847 PHMHANDLEDATA pHMHandleDataWrite,
1848 LPSECURITY_ATTRIBUTES lpsa,
1849 DWORD cbPipe)
1850{
1851 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreatePipe (%08x,%08x)\n",
1852 pHMHandleDataRead->hHMHandle,pHMHandleDataWrite->hHMHandle));
1853
1854 return(FALSE);
1855}
Note: See TracBrowser for help on using the repository browser.