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

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

mmap + share hack
File size: 56.4 KB
Line 
1/* $Id: hmdevice.cpp,v 1.22 2000-08-04 21:12:06 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 <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
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
1229 return(FALSE);
1230}
1231
1232/*****************************************************************************
1233 * Name : DWORD HMDeviceHandler::OpenThreadToken
1234 * Purpose :
1235 * Variables :
1236 * Result :
1237 * Remark :
1238 * Status :
1239 *
1240 * Author : SvL
1241 *****************************************************************************/
1242
1243DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
1244 HANDLE ThreadHandle,
1245 BOOL OpenAsSelf)
1246{
1247 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenThreadToken(%08xh,%08xh)\n",
1248 pHMHandleData->hHMHandle,
1249 ThreadHandle));
1250
1251 return ERROR_INVALID_HANDLE;
1252}
1253
1254/*****************************************************************************
1255 * Name : DWORD HMDeviceHandler::OpenThreadToken
1256 * Purpose :
1257 * Variables :
1258 * Result :
1259 * Remark :
1260 * Status :
1261 *
1262 * Author : SvL
1263 *****************************************************************************/
1264
1265DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
1266 DWORD dwUserData,
1267 HANDLE ProcessHandle)
1268{
1269 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenProcessToken(%08xh,%08xh)\n",
1270 pHMHandleData->hHMHandle,
1271 ProcessHandle));
1272
1273 return ERROR_INVALID_HANDLE;
1274}
1275/*****************************************************************************
1276 * Name : DWORD HMDeviceHandler::CreateThread
1277 * Purpose :
1278 * Variables :
1279 * Result :
1280 * Remark :
1281 * Status :
1282 *
1283 * Author : SvL
1284 *****************************************************************************/
1285HANDLE HMDeviceHandler::CreateThread(PHMHANDLEDATA pHMHandleData,
1286 LPSECURITY_ATTRIBUTES lpsa,
1287 DWORD cbStack,
1288 LPTHREAD_START_ROUTINE lpStartAddr,
1289 LPVOID lpvThreadParm,
1290 DWORD fdwCreate,
1291 LPDWORD lpIDThread,
1292 BOOL fFirstThread)
1293{
1294 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateThread %08xh",
1295 pHMHandleData->hHMHandle));
1296
1297 return ERROR_INVALID_HANDLE;
1298}
1299/*****************************************************************************
1300 * Name : DWORD HMDeviceHandler::GetThreadPriority
1301 * Purpose :
1302 * Variables :
1303 * Result :
1304 * Remark :
1305 * Status :
1306 *
1307 * Author : SvL
1308 *****************************************************************************/
1309INT HMDeviceHandler::GetThreadPriority(PHMHANDLEDATA pHMHandleData)
1310{
1311 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadPriority %08xh",
1312 pHMHandleData->hHMHandle));
1313
1314 return ERROR_INVALID_HANDLE;
1315}
1316/*****************************************************************************
1317 * Name : DWORD HMDeviceHandler::SuspendThread
1318 * Purpose :
1319 * Variables :
1320 * Result :
1321 * Remark :
1322 * Status :
1323 *
1324 * Author : SvL
1325 *****************************************************************************/
1326DWORD HMDeviceHandler::SuspendThread(PHMHANDLEDATA pHMHandleData)
1327{
1328 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SuspendThread %08xh",
1329 pHMHandleData->hHMHandle));
1330
1331 return ERROR_INVALID_HANDLE;
1332}
1333/*****************************************************************************
1334 * Name : DWORD HMDeviceHandler::SetThreadPriority
1335 * Purpose :
1336 * Variables :
1337 * Result :
1338 * Remark :
1339 * Status :
1340 *
1341 * Author : SvL
1342 *****************************************************************************/
1343BOOL HMDeviceHandler::SetThreadPriority(PHMHANDLEDATA pHMHandleData, int priority)
1344{
1345 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadPriority %08xh",
1346 pHMHandleData->hHMHandle));
1347
1348 return ERROR_INVALID_HANDLE;
1349}
1350/*****************************************************************************
1351 * Name : DWORD HMDeviceHandler::GetThreadContext
1352 * Purpose :
1353 * Variables :
1354 * Result :
1355 * Remark :
1356 * Status :
1357 *
1358 * Author : SvL
1359 *****************************************************************************/
1360BOOL HMDeviceHandler::GetThreadContext(PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext)
1361{
1362 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadContext %08xh",
1363 pHMHandleData->hHMHandle));
1364
1365 return ERROR_INVALID_HANDLE;
1366}
1367/*****************************************************************************
1368 * Name : DWORD HMDeviceHandler::SetThreadContext
1369 * Purpose :
1370 * Variables :
1371 * Result :
1372 * Remark :
1373 * Status :
1374 *
1375 * Author : SvL
1376 *****************************************************************************/
1377BOOL HMDeviceHandler::SetThreadContext(PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext)
1378{
1379 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadContext %08xh",
1380 pHMHandleData->hHMHandle));
1381
1382 return ERROR_INVALID_HANDLE;
1383}
1384/*****************************************************************************
1385 * Name : DWORD HMDeviceHandler::TerminateThread
1386 * Purpose :
1387 * Variables :
1388 * Result :
1389 * Remark :
1390 * Status :
1391 *
1392 * Author : SvL
1393 *****************************************************************************/
1394BOOL HMDeviceHandler::TerminateThread(PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1395{
1396 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1397 pHMHandleData->hHMHandle));
1398
1399 return ERROR_INVALID_HANDLE;
1400}
1401/*****************************************************************************
1402 * Name : DWORD HMDeviceHandler::ResumeThread
1403 * Purpose :
1404 * Variables :
1405 * Result :
1406 * Remark :
1407 * Status :
1408 *
1409 * Author : SvL
1410 *****************************************************************************/
1411DWORD HMDeviceHandler::ResumeThread(PHMHANDLEDATA pHMHandleData)
1412{
1413 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1414 pHMHandleData->hHMHandle));
1415
1416 return ERROR_INVALID_HANDLE;
1417}
1418/*****************************************************************************
1419 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1420 * Purpose :
1421 * Variables :
1422 * Result :
1423 * Remark :
1424 * Status :
1425 *
1426 * Author : SvL
1427 *****************************************************************************/
1428BOOL HMDeviceHandler::GetExitCodeThread(PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1429{
1430 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1431 pHMHandleData->hHMHandle));
1432
1433 return ERROR_INVALID_HANDLE;
1434}
1435/*****************************************************************************
1436 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1437 * Purpose :
1438 * Variables :
1439 * Result :
1440 * Remark :
1441 * Status :
1442 *
1443 * Author : SvL
1444 *****************************************************************************/
1445BOOL HMDeviceHandler::SetThreadTerminated(PHMHANDLEDATA pHMHandleData)
1446{
1447 return FALSE;
1448}
1449
1450/*****************************************************************************
1451 * Name : DWORD HMDeviceHandler::PeekNamedPipe
1452 * Purpose :
1453 * Variables :
1454 * Result :
1455 * Remark :
1456 * Status :
1457 *
1458 * Author : Przemyslaw Dobrowolski
1459 *****************************************************************************/
1460BOOL HMDeviceHandler::PeekNamedPipe(PHMHANDLEDATA pHMHandleData,
1461 LPVOID lpvBuffer,
1462 DWORD cbBuffer,
1463 LPDWORD lpcbRead,
1464 LPDWORD lpcbAvail,
1465 LPDWORD lpcbMessage)
1466{
1467 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::PeekNamedPipe (%08x)\n",
1468 pHMHandleData->hHMHandle));
1469
1470 return (FALSE);
1471}
1472
1473/*****************************************************************************
1474 * Name : DWORD HMDeviceHandler::CreateNamedPipe
1475 * Purpose :
1476 * Variables :
1477 * Result :
1478 * Remark :
1479 * Status :
1480 *
1481 * Author : Przemyslaw Dobrowolski
1482 *****************************************************************************/
1483DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
1484 LPCTSTR lpName,
1485 DWORD dwOpenMode,
1486 DWORD dwPipeMode,
1487 DWORD nMaxInstances,
1488 DWORD nOutBufferSize,
1489 DWORD nInBufferSize,
1490 DWORD nDefaultTimeOut,
1491 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1492{
1493 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateNamedPipe (%s)\n",
1494 lpName));
1495
1496 return ERROR_INVALID_HANDLE;
1497}
1498
1499/*****************************************************************************
1500 * Name : BOOL HMDeviceHandler::ConnectNamedPipe
1501 * Purpose :
1502 * Variables :
1503 * Result :
1504 * Remark :
1505 * Status :
1506 *
1507 * Author : Przemyslaw Dobrowolski
1508 *****************************************************************************/
1509BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
1510 LPOVERLAPPED lpOverlapped)
1511{
1512 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ConnectNamedPipe (%08x)\n",
1513 pHMHandleData->hHMHandle));
1514
1515 return FALSE;
1516}
1517
1518/*****************************************************************************
1519 * Name : BOOL HMDeviceHandler::DisconnectNamedPipe
1520 * Purpose :
1521 * Variables :
1522 * Result :
1523 * Remark :
1524 * Status :
1525 *
1526 * Author : Przemyslaw Dobrowolski
1527 *****************************************************************************/
1528BOOL HMDeviceHandler::DisconnectNamedPipe(PHMHANDLEDATA pHMHandleData)
1529{
1530 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::DisconnectNamedPipe (%08x)\n",
1531 pHMHandleData->hHMHandle));
1532
1533 return FALSE;
1534}
1535
1536/*****************************************************************************
1537 * Name : BOOL HMDeviceHandler::GetNamedPipeHandleState
1538 * Purpose :
1539 * Variables :
1540 * Result :
1541 * Remark :
1542 * Status :
1543 *
1544 * Author : Przemyslaw Dobrowolski
1545 *****************************************************************************/
1546BOOL HMDeviceHandler::GetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1547 LPDWORD lpState,
1548 LPDWORD lpCurInstances,
1549 LPDWORD lpMaxCollectionCount,
1550 LPDWORD lpCollectDataTimeout,
1551 LPTSTR lpUserName,
1552 DWORD nMaxUserNameSize)
1553{
1554 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeHandleState (%08x)\n",
1555 pHMHandleData->hHMHandle));
1556
1557 return FALSE;
1558}
1559
1560/*****************************************************************************
1561 * Name : BOOL HMDeviceHandler::GetNamedPipeInfo
1562 * Purpose :
1563 * Variables :
1564 * Result :
1565 * Remark :
1566 * Status :
1567 *
1568 * Author : Przemyslaw Dobrowolski
1569 *****************************************************************************/
1570BOOL HMDeviceHandler::GetNamedPipeInfo(PHMHANDLEDATA pHMHandleData,
1571 LPDWORD lpFlags,
1572 LPDWORD lpOutBufferSize,
1573 LPDWORD lpInBufferSize,
1574 LPDWORD lpMaxInstances)
1575{
1576 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetNamedPipeInfo (%08x)\n",
1577 pHMHandleData->hHMHandle));
1578
1579 return FALSE;
1580}
1581
1582/*****************************************************************************
1583 * Name : DWORD HMDeviceHandler::TransactNamedPipe
1584 * Purpose :
1585 * Variables :
1586 * Result :
1587 * Remark :
1588 * Status :
1589 *
1590 * Author : Przemyslaw Dobrowolski
1591 *****************************************************************************/
1592DWORD HMDeviceHandler::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
1593 LPVOID lpvWriteBuf,
1594 DWORD cbWriteBuf,
1595 LPVOID lpvReadBuf,
1596 DWORD cbReadBuf,
1597 LPDWORD lpcbRead,
1598 LPOVERLAPPED lpo)
1599{
1600 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TransactNamedPipe (%08x)\n",
1601 pHMHandleData->hHMHandle));
1602
1603 return FALSE;
1604}
1605
1606/*****************************************************************************
1607 * Name : BOOL HMDeviceHandler::SetNamedPipeHandleState
1608 * Purpose :
1609 * Variables :
1610 * Result :
1611 * Remark :
1612 * Status :
1613 *
1614 * Author : Przemyslaw Dobrowolski
1615 *****************************************************************************/
1616BOOL HMDeviceHandler::SetNamedPipeHandleState(PHMHANDLEDATA pHMHandleData,
1617 LPDWORD lpdwMode,
1618 LPDWORD lpcbMaxCollect,
1619 LPDWORD lpdwCollectDataTimeout)
1620{
1621 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetNamedPipeHandleState (%08x)\n",
1622 pHMHandleData->hHMHandle));
1623
1624 return FALSE;
1625}
1626
1627/*****************************************************************************
1628 * Name : BOOL HMDeviceHandler::CreatePipe
1629 * Purpose :
1630 * Variables :
1631 * Result :
1632 * Remark :
1633 * Status :
1634 *
1635 * Author : Przemyslaw Dobrowolski
1636 *****************************************************************************/
1637BOOL HMDeviceHandler::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
1638 PHMHANDLEDATA pHMHandleDataWrite,
1639 LPSECURITY_ATTRIBUTES lpsa,
1640 DWORD cbPipe)
1641{
1642 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreatePipe (%08x,%08x)\n",
1643 pHMHandleDataRead->hHMHandle,pHMHandleDataWrite->hHMHandle));
1644
1645 return(FALSE);
1646}
Note: See TracBrowser for help on using the repository browser.