source: trunk/src/kernel32/hmdevice.cpp

Last change on this file was 22024, checked in by dmik, 13 years ago

kernel32: Fix inverted return values in dummy HMDeviceHandler implementations.

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