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

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

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