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

Last change on this file since 4285 was 4285, checked in by hugh, 25 years ago

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