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

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

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