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

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

semaphore rewrite (not activated)
File size: 64.5 KB
Line 
1/* $Id: hmdevice.cpp,v 1.27 2001-06-19 10:50:23 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 * Name : DWORD HMDeviceHandler::WaitForSingleObject
987 * Purpose : object synchronization
988 * Parameters: PHMHANDLEDATA pHMHandleData
989 * DWORD dwTimeout
990 * Variables :
991 * Result : API returncode
992 * Remark :
993 * Status :
994 *
995 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
996 *****************************************************************************/
997
998DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
999 DWORD dwTimeout)
1000{
1001 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObject(%08xh,%08h)\n",
1002 pHMHandleData->hHMHandle,
1003 dwTimeout));
1004
1005 return(ERROR_INVALID_FUNCTION);
1006}
1007
1008
1009/*****************************************************************************
1010 * Name : DWORD HMDeviceHandler::WaitForSingleObjectEx
1011 * Purpose : object synchronization
1012 * Parameters: PHMHANDLEDATA pHMHandleData
1013 * DWORD dwTimeout
1014 * BOOL fAlertable
1015 * Variables :
1016 * Result : API returncode
1017 * Remark :
1018 * Status :
1019 *
1020 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1021 *****************************************************************************/
1022
1023DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
1024 DWORD dwTimeout,
1025 BOOL fAlertable)
1026{
1027 dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
1028 pHMHandleData->hHMHandle,
1029 dwTimeout,
1030 fAlertable));
1031
1032 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
1033 return(ERROR_INVALID_FUNCTION);
1034}
1035
1036
1037/*****************************************************************************
1038 * Name : DWORD HMDeviceHandler::FlushFileBuffers
1039 * Purpose : flush the buffers of a file
1040 * Parameters: PHMHANDLEDATA pHMHandleData
1041 * Variables :
1042 * Result : API returncode
1043 * Remark :
1044 * Status :
1045 *
1046 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1047 *****************************************************************************/
1048
1049BOOL HMDeviceHandler::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
1050{
1051 dprintf(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
1052 pHMHandleData->hHMHandle));
1053
1054 return(ERROR_INVALID_FUNCTION);
1055}
1056
1057
1058/*****************************************************************************
1059 * Name : DWORD HMDeviceHandler::GetOverlappedResult
1060 * Purpose : asynchronus I/O
1061 * Parameters: PHMHANDLEDATA pHMHandleData
1062 * LPOVERLAPPED arg2
1063 * LPDWORD arg3
1064 * BOOL arg4
1065 * Variables :
1066 * Result : API returncode
1067 * Remark :
1068 * Status :
1069 *
1070 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1071 *****************************************************************************/
1072
1073BOOL HMDeviceHandler::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
1074 LPOVERLAPPED arg2,
1075 LPDWORD arg3,
1076 BOOL arg4)
1077{
1078 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
1079 pHMHandleData->hHMHandle,
1080 arg2,
1081 arg3,
1082 arg4));
1083
1084 return(ERROR_INVALID_FUNCTION);
1085}
1086
1087/*****************************************************************************
1088 * Name : DWORD HMDeviceHandler::CreateFileMapping
1089 * Purpose : create memory mapped file
1090 * Parameters: PHMHANDLEDATA pHMHandleData
1091 * LPSECURITY_ATTRIBUTES lpFileMappingAttributes
1092 * DWORD flProtect
1093 * DWORD dwMaximumSizeHigh
1094 * DWORD dwMaximumSizeLow
1095 * LPCTSTR lpName
1096 * Variables :
1097 * Result : API returncode
1098 * Remark :
1099 * Status :
1100 *
1101 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1102 *****************************************************************************/
1103
1104DWORD HMDeviceHandler::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
1105 HANDLE hFile,
1106 LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
1107 DWORD flProtect,
1108 DWORD dwMaximumSizeHigh,
1109 DWORD dwMaximumSizeLow,
1110 LPCSTR lpName)
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}
1856/*****************************************************************************
1857 * Name : BOOL HMDeviceHandler::GetMailslotInfo
1858 * Purpose :
1859 * Variables :
1860 * Result :
1861 * Remark :
1862 * Status :
1863 *
1864 * Author : SvL
1865 *****************************************************************************/
1866BOOL HMDeviceHandler::GetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1867 LPDWORD lpMaxMessageSize,
1868 LPDWORD lpNextSize,
1869 LPDWORD lpMessageCount,
1870 LPDWORD lpReadTimeout)
1871{
1872 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetMailslotInfo %08x",
1873 pHMHandleData->hHMHandle));
1874
1875 return(FALSE);
1876}
1877/*****************************************************************************
1878 * Name : BOOL HMDeviceHandler::SetMailslotInfo
1879 * Purpose :
1880 * Variables :
1881 * Result :
1882 * Remark :
1883 * Status :
1884 *
1885 * Author : SvL
1886 *****************************************************************************/
1887BOOL HMDeviceHandler::SetMailslotInfo(PHMHANDLEDATA pHMHandleData,
1888 DWORD dwReadTimeout)
1889{
1890 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetMailslotInfo %08x %x",
1891 pHMHandleData->hHMHandle, dwReadTimeout));
1892
1893 return(FALSE);
1894}
Note: See TracBrowser for help on using the repository browser.