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
Line 
1/* $Id: hmdevice.cpp,v 1.37 2003-06-02 16:25:16 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 * 1998/02/11 PH Patrick Haller (haller@zebra.fh-weingarten.de)
7 */
8
9
10/*****************************************************************************
11 * Remark *
12 *****************************************************************************
13 */
14
15
16/*****************************************************************************
17 * Includes *
18 *****************************************************************************/
19
20#include <odin.h>
21#include <os2win.h>
22#include <string.h>
23#include <misc.h>
24#include "HandleManager.h"
25#include "HMDevice.h"
26
27#define DBG_LOCALLOG DBG_hmdevice
28#include "dbglocal.h"
29
30
31/*****************************************************************************
32 * Defines *
33 *****************************************************************************/
34
35#ifndef ERROR_INVALID_FUNCTION
36#define ERROR_INVALID_FUNCTION 1
37#endif
38
39/*****************************************************************************
40 * Structures *
41 *****************************************************************************/
42
43
44/*****************************************************************************
45 * This pseudo-device logs all device requests to the logfile and returns *
46 * ERROR_INVALID_FUNCTION to virtually all requests -> debugging *
47 *****************************************************************************/
48class HMDeviceDebugClass : public HMDeviceHandler
49{
50 public:
51 HMDeviceDebugClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
52};
53
54
55/*****************************************************************************
56 * Name : HMDeviceHandler::HMDeviceHandler
57 * Purpose : default constructor for a device handler object
58 * Parameters: LPCSTR lpDeviceName
59 * Variables :
60 * Result :
61 * Remark : this is only to identify the device for debugging purposes
62 * Status :
63 *
64 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
65 *****************************************************************************/
66
67HMDeviceHandler::HMDeviceHandler(LPCSTR lpDeviceName)
68{
69 /* only a reference on the device name */
70 HMDeviceHandler::lpHMDeviceName = lpDeviceName;
71}
72
73
74/*****************************************************************************
75 * Name : HMDeviceHandler::FindDevice
76 * Purpose : Checks if lpDeviceName belongs to this device class
77 * Parameters: LPCSTR lpClassDevName
78 * LPCSTR lpDeviceName
79 * int namelength
80 * Variables :
81 * Result :
82 * Remark :
83 * Status :
84 *
85 * Author : SvL
86 *****************************************************************************/
87BOOL HMDeviceHandler::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
88{
89 if(stricmp(lpClassDevName, lpDeviceName) == 0) {
90 return TRUE;
91 }
92 return FALSE;
93}
94
95/*****************************************************************************
96 * Name : HMDeviceHandler::_DeviceReuqest
97 * Purpose : entry method for special request functions
98 * Parameters: ULONG ulRequestCode
99 * various parameters as required
100 * Variables :
101 * Result :
102 * Remark : the standard behaviour is to return an error code for non-
103 * existant request codes
104 * Status :
105 *
106 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
107 *****************************************************************************/
108DWORD HMDeviceHandler::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
109 ULONG ulRequestCode,
110 ULONG arg1,
111 ULONG arg2,
112 ULONG arg3,
113 ULONG arg4)
114{
115 dprintf(("KERNEL32:HandleManager::_DeviceRequest %s(%08x,%08x) - stub?\n",
116 lpHMDeviceName,
117 pHMHandleData,
118 ulRequestCode));
119
120 SetLastError(ERROR_INVALID_FUNCTION);
121 return FALSE;
122}
123
124
125/*****************************************************************************
126 * Name : HMDeviceHandler::DuplicateHandle
127 * Purpose : dummy version
128 * Parameters:
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 *****************************************************************************/
138BOOL HMDeviceHandler::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
139 PHMHANDLEDATA pHMSrcHandle,
140 HANDLE destprocess,
141 DWORD fdwAccess,
142 BOOL fInherit,
143 DWORD fdwOptions,
144 DWORD fdwOdinOptions)
145{
146 dprintf(("KERNEL32:HandleManager::DuplicateHandle %s(%08x,%08x,%08x,%08x) - NOT IMPLEMENTED!!!!!!!!\n",
147 lpHMDeviceName, pHMHandleData, srcprocess, pHMSrcHandle, destprocess));
148
149 SetLastError(ERROR_INVALID_FUNCTION);
150 return FALSE;
151}
152
153/*****************************************************************************
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
170DWORD HMDeviceHandler::CreateFile (LPCSTR lpFileName,
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
182 SetLastError(ERROR_INVALID_FUNCTION);
183 return NULL;
184}
185
186
187/*****************************************************************************
188 * Name : DWORD HMDeviceHandler::CloseHandle
189 * Purpose : close the handle
190 * Parameters: PHMHANDLEDATA pHMHandleData
191 * Variables :
192 * Result : API returncode
193 * Remark :
194 * Status :
195 *
196 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
197 *****************************************************************************/
198
199BOOL HMDeviceHandler::CloseHandle(PHMHANDLEDATA pHMHandleData)
200{
201 dprintf(("KERNEL32:HandleManager::CloseHandle %s(%08x) - stub?\n",
202 lpHMDeviceName,
203 pHMHandleData));
204
205 SetLastError(ERROR_INVALID_FUNCTION);
206 return FALSE;
207}
208
209/*****************************************************************************
210 * 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));
230
231 SetLastError(ERROR_INVALID_FUNCTION);
232 return FALSE;
233}
234
235
236/*****************************************************************************
237 * Name : BOOL HMDeviceHandler::ReadFile
238 * Purpose : read data from handle / device
239 * Parameters: PHMHANDLEDATA pHMHandleData,
240 * LPCVOID lpBuffer,
241 * DWORD nNumberOfBytesToRead,
242 * LPDWORD lpNumberOfBytesRead,
243 * LPOVERLAPPED lpOverlapped
244 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
245 * Variables :
246 * Result : Boolean
247 * Remark :
248 * Status :
249 *
250 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
251 *****************************************************************************/
252
253BOOL HMDeviceHandler::ReadFile(PHMHANDLEDATA pHMHandleData,
254 LPCVOID lpBuffer,
255 DWORD nNumberOfBytesToRead,
256 LPDWORD lpNumberOfBytesRead,
257 LPOVERLAPPED lpOverlapped,
258 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
259{
260 dprintf(("KERNEL32:HandleManager::ReadFile %s(%08x,%08x,%08x,%08x,%08x %08x) - stub?\n",
261 lpHMDeviceName,
262 pHMHandleData->hHMHandle,
263 lpBuffer,
264 nNumberOfBytesToRead,
265 lpNumberOfBytesRead,
266 lpOverlapped, lpCompletionRoutine));
267
268 SetLastError(ERROR_INVALID_FUNCTION);
269 return FALSE;
270}
271
272
273/*****************************************************************************
274 * Name : BOOL HMDeviceHandler::WriteFile
275 * Purpose : write data to handle / device
276 * Parameters: PHMHANDLEDATA pHMHandleData,
277 * LPCVOID lpBuffer,
278 * DWORD nNumberOfBytesToWrite,
279 * LPDWORD lpNumberOfBytesWritten,
280 * LPOVERLAPPED lpOverlapped
281 * LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
282 * Variables :
283 * Result : Boolean
284 * Remark :
285 * Status :
286 *
287 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
288 *****************************************************************************/
289
290BOOL HMDeviceHandler::WriteFile(PHMHANDLEDATA pHMHandleData,
291 LPCVOID lpBuffer,
292 DWORD nNumberOfBytesToWrite,
293 LPDWORD lpNumberOfBytesWritten,
294 LPOVERLAPPED lpOverlapped,
295 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
296{
297 dprintf(("KERNEL32:HandleManager::WriteFile %s(%08x,%08x,%08x,%08x,%08x,%08x) - stub?\n",
298 lpHMDeviceName,
299 pHMHandleData->hHMHandle,
300 lpBuffer,
301 nNumberOfBytesToWrite,
302 lpNumberOfBytesWritten,
303 lpOverlapped, lpCompletionRoutine));
304
305 SetLastError(ERROR_INVALID_FUNCTION);
306 return FALSE;
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
327 SetLastError(ERROR_INVALID_FUNCTION);
328 return FILE_TYPE_UNKNOWN;
329}
330
331
332/*****************************************************************************
333 * Name : BOOL HMDeviceHandler::GetFileInformationByHandle
334 * Purpose : determine the handle type
335 * Parameters: PHMHANDLEDATA pHMHandleData
336 * BY_HANDLE_FILE_INFORMATION* pHFI
337 * Variables :
338 * Result : Success indicator
339 * Remark :
340 * Status :
341 *
342 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
343 *****************************************************************************/
344
345BOOL HMDeviceHandler::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
346 BY_HANDLE_FILE_INFORMATION* pHFI)
347{
348 dprintf(("KERNEL32: HandleManager::DeviceHandler::GetFileInformationByHandle %s(%08xh,%08xh)\n",
349 lpHMDeviceName,
350 pHMHandleData,
351 pHFI));
352
353 SetLastError(ERROR_INVALID_FUNCTION);
354 return FALSE;
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
376 SetLastError(ERROR_INVALID_FUNCTION);
377 return FALSE;
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
408 SetLastError(ERROR_INVALID_FUNCTION);
409 return FALSE;
410}
411
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 *****************************************************************************/
426
427BOOL HMDeviceHandler::GetFileTime(PHMHANDLEDATA pHMHandleData,
428 LPFILETIME pFT1,
429 LPFILETIME pFT2,
430 LPFILETIME pFT3)
431{
432 DebugInt3();
433 SetLastError(ERROR_INVALID_FUNCTION);
434 return FALSE;
435}
436
437
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
459 SetLastError(ERROR_INVALID_FUNCTION);
460 return INVALID_SET_FILE_POINTER;
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
491 SetLastError(ERROR_INVALID_FUNCTION);
492 return INVALID_SET_FILE_POINTER;
493}
494
495
496/*****************************************************************************
497 * Name : BOOL HMDeviceHandler::LockFile
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
512BOOL HMDeviceHandler::LockFile(PHMHANDLEDATA pHMHandleData,
513 DWORD arg2,
514 DWORD arg3,
515 DWORD arg4,
516 DWORD arg5)
517{
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));
525
526 SetLastError(ERROR_INVALID_FUNCTION);
527 return FALSE;
528}
529
530
531
532/*****************************************************************************
533 * Name : BOOL HMDeviceHandler::LockFileEx
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
549BOOL HMDeviceHandler::LockFileEx(PHMHANDLEDATA pHMHandleData,
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
566 SetLastError(ERROR_INVALID_FUNCTION);
567 return FALSE;
568}
569
570
571/*****************************************************************************
572 * Name : BOOL HMDeviceHandler::OpenFile
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
588BOOL HMDeviceHandler::OpenFile (LPCSTR lpFileName,
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
600 SetLastError(ERROR_INVALID_FUNCTION);
601 return FALSE;
602}
603
604
605/*****************************************************************************
606 * Name : BOOL HMDeviceHandler::UnlockFile
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
621BOOL HMDeviceHandler::UnlockFile(PHMHANDLEDATA pHMHandleData,
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
635 SetLastError(ERROR_INVALID_FUNCTION);
636 return FALSE;
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
657BOOL HMDeviceHandler::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
658 DWORD dwReserved,
659 DWORD nNumberOfBytesToLockLow,
660 DWORD nNumberOfBytesToLockHigh,
661 LPOVERLAPPED lpOverlapped)
662{
663 dprintf(("KERNEL32: HandleManager::DeviceHandler::UnlockFileEx %s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
664 lpHMDeviceName,
665 pHMHandleData,
666 dwReserved,
667 nNumberOfBytesToLockLow,
668 nNumberOfBytesToLockHigh,
669 lpOverlapped));
670
671 SetLastError(ERROR_INVALID_FUNCTION);
672 return FALSE;
673}
674
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
702 SetLastError(ERROR_INVALID_FUNCTION);
703 return NULL;
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
728 SetLastError(ERROR_INVALID_FUNCTION);
729 return NULL;
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
754 SetLastError(ERROR_INVALID_FUNCTION);
755 return FALSE;
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
783 SetLastError(ERROR_INVALID_FUNCTION);
784 return NULL;
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
809 SetLastError(ERROR_INVALID_FUNCTION);
810 return NULL;
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
831 SetLastError(ERROR_INVALID_FUNCTION);
832 return FALSE;
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
861 SetLastError(ERROR_INVALID_FUNCTION);
862 return NULL;
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
887 SetLastError(ERROR_INVALID_FUNCTION);
888 return NULL;
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
909 SetLastError(ERROR_INVALID_FUNCTION);
910 return FALSE;
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
952 SetLastError(ERROR_INVALID_FUNCTION);
953 return FALSE;
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
976 SetLastError(ERROR_INVALID_FUNCTION);
977 return FALSE;
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
1007 SetLastError(ERROR_INVALID_FUNCTION);
1008 return FALSE;
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,
1034 LPCSTR lpName)
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
1045 SetLastError(ERROR_INVALID_FUNCTION);
1046 return NULL;
1047}
1048
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,
1066 DWORD fdwAccess,
1067 BOOL fInherit,
1068 LPCTSTR lpName)
1069{
1070 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
1071 pHMHandleData->hHMHandle,
1072 fdwAccess,
1073 fInherit,
1074 lpName));
1075
1076 SetLastError(ERROR_INVALID_FUNCTION);
1077 return NULL;
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
1096LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
1097 DWORD dwDesiredAccess,
1098 DWORD dwFileOffsetHigh,
1099 DWORD dwFileOffsetLow,
1100 DWORD dwNumberOfBytesToMap,
1101 LPVOID lpBaseAddress)
1102{
1103 dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
1104 pHMHandleData->hHMHandle,
1105 dwDesiredAccess,
1106 dwFileOffsetHigh,
1107 dwFileOffsetLow,
1108 dwNumberOfBytesToMap, lpBaseAddress));
1109
1110 SetLastError(ERROR_INVALID_FUNCTION);
1111 return NULL;
1112}
1113
1114/*****************************************************************************
1115 * Name : DWORD HMDeviceHandler::DeviceIoControl
1116 * Purpose : send command to device driver
1117 * Variables :
1118 * Result :
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
1137 SetLastError(ERROR_INVALID_FUNCTION);
1138 return FALSE;
1139}
1140
1141/*****************************************************************************
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/*****************************************************************************
1159 * Name : DWORD HMDeviceHandler::SetupComm
1160 * Purpose : set com port parameters (queue)
1161 * Variables :
1162 * Result :
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));
1174 SetLastError(ERROR_INVALID_HANDLE);
1175 return(FALSE);
1176}
1177
1178
1179/*****************************************************************************
1180 * Name : DWORD HMDeviceHandler::GetCommState
1181 * Purpose : query com port control block
1182 * Variables :
1183 * Result :
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));
1194 SetLastError(ERROR_INVALID_HANDLE);
1195 return(FALSE);
1196}
1197
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);
1207 return(FALSE);
1208}
1209
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
1385/*****************************************************************************
1386 * Name : DWORD HMDeviceHandler::OpenThreadToken
1387 * Purpose :
1388 * Variables :
1389 * Result :
1390 * Remark :
1391 * Status :
1392 *
1393 * Author : SvL
1394 *****************************************************************************/
1395
1396DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
1397 HANDLE ThreadHandle,
1398 BOOL OpenAsSelf)
1399{
1400 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenThreadToken(%08xh,%08xh)\n",
1401 pHMHandleData->hHMHandle,
1402 ThreadHandle));
1403
1404 SetLastError(ERROR_INVALID_FUNCTION);
1405 return NULL;
1406}
1407
1408/*****************************************************************************
1409 * Name : DWORD HMDeviceHandler::OpenThreadToken
1410 * Purpose :
1411 * Variables :
1412 * Result :
1413 * Remark :
1414 * Status :
1415 *
1416 * Author : SvL
1417 *****************************************************************************/
1418
1419DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
1420 DWORD dwUserData,
1421 HANDLE ProcessHandle)
1422{
1423 dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenProcessToken(%08xh,%08xh)\n",
1424 pHMHandleData->hHMHandle,
1425 ProcessHandle));
1426
1427 SetLastError(ERROR_INVALID_FUNCTION);
1428 return NULL;
1429}
1430/*****************************************************************************
1431 * Name : DWORD HMDeviceHandler::CreateThread
1432 * Purpose :
1433 * Variables :
1434 * Result :
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,
1446 LPDWORD lpIDThread,
1447 BOOL fRegisterThread)
1448{
1449 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateThread %08xh",
1450 pHMHandleData->hHMHandle));
1451
1452 SetLastError(ERROR_INVALID_FUNCTION);
1453 return NULL;
1454}
1455/*****************************************************************************
1456 * Name : DWORD HMDeviceHandler::GetThreadPriority
1457 * Purpose :
1458 * Variables :
1459 * Result :
1460 * Remark :
1461 * Status :
1462 *
1463 * Author : SvL
1464 *****************************************************************************/
1465INT HMDeviceHandler::GetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1466{
1467 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadPriority %08xh",
1468 pHMHandleData->hHMHandle));
1469
1470 SetLastError(ERROR_INVALID_FUNCTION);
1471 return THREAD_PRIORITY_ERROR_RETURN;
1472}
1473/*****************************************************************************
1474 * Name : DWORD HMDeviceHandler::SuspendThread
1475 * Purpose :
1476 * Variables :
1477 * Result :
1478 * Remark :
1479 * Status :
1480 *
1481 * Author : SvL
1482 *****************************************************************************/
1483DWORD HMDeviceHandler::SuspendThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1484{
1485 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SuspendThread %08xh",
1486 pHMHandleData->hHMHandle));
1487
1488 SetLastError(ERROR_INVALID_FUNCTION);
1489 return -1;
1490}
1491/*****************************************************************************
1492 * Name : DWORD HMDeviceHandler::SetThreadPriority
1493 * Purpose :
1494 * Variables :
1495 * Result :
1496 * Remark :
1497 * Status :
1498 *
1499 * Author : SvL
1500 *****************************************************************************/
1501BOOL HMDeviceHandler::SetThreadPriority(HANDLE hThread, PHMHANDLEDATA pHMHandleData, int priority)
1502{
1503 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadPriority %08xh",
1504 pHMHandleData->hHMHandle));
1505
1506 SetLastError(ERROR_INVALID_FUNCTION);
1507 return FALSE;
1508}
1509/*****************************************************************************
1510 * Name : DWORD HMDeviceHandler::GetThreadContext
1511 * Purpose :
1512 * Variables :
1513 * Result :
1514 * Remark :
1515 * Status :
1516 *
1517 * Author : SvL
1518 *****************************************************************************/
1519BOOL HMDeviceHandler::GetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, PCONTEXT lpContext)
1520{
1521 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetThreadContext %08xh",
1522 pHMHandleData->hHMHandle));
1523
1524 SetLastError(ERROR_INVALID_FUNCTION);
1525 return FALSE;
1526}
1527/*****************************************************************************
1528 * Name : DWORD HMDeviceHandler::SetThreadContext
1529 * Purpose :
1530 * Variables :
1531 * Result :
1532 * Remark :
1533 * Status :
1534 *
1535 * Author : SvL
1536 *****************************************************************************/
1537BOOL HMDeviceHandler::SetThreadContext(HANDLE hThread, PHMHANDLEDATA pHMHandleData, const CONTEXT *lpContext)
1538{
1539 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::SetThreadContext %08xh",
1540 pHMHandleData->hHMHandle));
1541
1542 SetLastError(ERROR_INVALID_FUNCTION);
1543 return FALSE;
1544}
1545/*****************************************************************************
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
1569 SetLastError(ERROR_INVALID_FUNCTION);
1570 return FALSE;
1571}
1572
1573/*****************************************************************************
1574 * Name : DWORD HMDeviceHandler::TerminateThread
1575 * Purpose :
1576 * Variables :
1577 * Result :
1578 * Remark :
1579 * Status :
1580 *
1581 * Author : SvL
1582 *****************************************************************************/
1583BOOL HMDeviceHandler::TerminateThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, DWORD exitcode)
1584{
1585 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::TerminateThread %08xh",
1586 pHMHandleData->hHMHandle));
1587
1588 SetLastError(ERROR_INVALID_FUNCTION);
1589 return FALSE;
1590}
1591/*****************************************************************************
1592 * Name : DWORD HMDeviceHandler::ResumeThread
1593 * Purpose :
1594 * Variables :
1595 * Result :
1596 * Remark :
1597 * Status :
1598 *
1599 * Author : SvL
1600 *****************************************************************************/
1601DWORD HMDeviceHandler::ResumeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1602{
1603 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ResumeThread %08xh",
1604 pHMHandleData->hHMHandle));
1605
1606 SetLastError(ERROR_INVALID_FUNCTION);
1607 return -1;
1608}
1609/*****************************************************************************
1610 * Name : DWORD HMDeviceHandler::GetExitCodeThread
1611 * Purpose :
1612 * Variables :
1613 * Result :
1614 * Remark :
1615 * Status :
1616 *
1617 * Author : SvL
1618 *****************************************************************************/
1619BOOL HMDeviceHandler::GetExitCodeThread(HANDLE hThread, PHMHANDLEDATA pHMHandleData, LPDWORD lpExitCode)
1620{
1621 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::GetExitCodeThread %08xh",
1622 pHMHandleData->hHMHandle));
1623
1624 SetLastError(ERROR_INVALID_FUNCTION);
1625 return FALSE;
1626}
1627/*****************************************************************************
1628 * Name : DWORD HMDeviceHandler::SetThreadTerminated
1629 * Purpose :
1630 * Variables :
1631 * Result :
1632 * Remark :
1633 * Status :
1634 *
1635 * Author : SvL
1636 *****************************************************************************/
1637BOOL HMDeviceHandler::SetThreadTerminated(HANDLE hThread, PHMHANDLEDATA pHMHandleData)
1638{
1639 SetLastError(ERROR_INVALID_FUNCTION);
1640 return FALSE;
1641}
1642
1643/*****************************************************************************
1644 * Name : DWORD HMDeviceHandler::PeekNamedPipe
1645 * Purpose :
1646 * Variables :
1647 * Result :
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
1663 SetLastError(ERROR_INVALID_FUNCTION);
1664 return (FALSE);
1665}
1666
1667/*****************************************************************************
1668 * Name : DWORD HMDeviceHandler::CreateNamedPipe
1669 * Purpose :
1670 * Variables :
1671 * Result :
1672 * Remark :
1673 * Status :
1674 *
1675 * Author : Przemyslaw Dobrowolski
1676 *****************************************************************************/
1677DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
1678 LPCTSTR lpName,
1679 DWORD dwOpenMode,
1680 DWORD dwPipeMode,
1681 DWORD nMaxInstances,
1682 DWORD nOutBufferSize,
1683 DWORD nInBufferSize,
1684 DWORD nDefaultTimeOut,
1685 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
1686{
1687 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreateNamedPipe (%s)\n",
1688 lpName));
1689
1690 SetLastError(ERROR_INVALID_FUNCTION);
1691 return NULL;
1692}
1693
1694/*****************************************************************************
1695 * Name : BOOL HMDeviceHandler::ConnectNamedPipe
1696 * Purpose :
1697 * Variables :
1698 * Result :
1699 * Remark :
1700 * Status :
1701 *
1702 * Author : Przemyslaw Dobrowolski
1703 *****************************************************************************/
1704BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
1705 LPOVERLAPPED lpOverlapped)
1706{
1707 dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::ConnectNamedPipe (%08x)\n",
1708 pHMHandleData->hHMHandle));
1709
1710 SetLastError(ERROR_INVALID_FUNCTION);
1711 return FALSE;
1712}
1713
1714/*****************************************************************************
1715 * Name : BOOL HMDeviceHandler::DisconnectNamedPipe
1716 * Purpose :
1717 * Variables :
1718 * Result :
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
1729 SetLastError(ERROR_INVALID_FUNCTION);
1730 return FALSE;
1731}
1732
1733/*****************************************************************************
1734 * Name : BOOL HMDeviceHandler::GetNamedPipeHandleState
1735 * Purpose :
1736 * Variables :
1737 * Result :
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
1754 SetLastError(ERROR_INVALID_FUNCTION);
1755 return FALSE;
1756}
1757
1758/*****************************************************************************
1759 * Name : BOOL HMDeviceHandler::GetNamedPipeInfo
1760 * Purpose :
1761 * Variables :
1762 * Result :
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
1777 SetLastError(ERROR_INVALID_FUNCTION);
1778 return FALSE;
1779}
1780
1781/*****************************************************************************
1782 * Name : DWORD HMDeviceHandler::TransactNamedPipe
1783 * Purpose :
1784 * Variables :
1785 * Result :
1786 * Remark :
1787 * Status :
1788 *
1789 * Author : Przemyslaw Dobrowolski
1790 *****************************************************************************/
1791BOOL HMDeviceHandler::TransactNamedPipe(PHMHANDLEDATA pHMHandleData,
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
1802 SetLastError(ERROR_INVALID_FUNCTION);
1803 return FALSE;
1804}
1805
1806/*****************************************************************************
1807 * Name : BOOL HMDeviceHandler::SetNamedPipeHandleState
1808 * Purpose :
1809 * Variables :
1810 * Result :
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
1824 SetLastError(ERROR_INVALID_FUNCTION);
1825 return FALSE;
1826}
1827
1828/*****************************************************************************
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
1847 SetLastError(ERROR_INVALID_FUNCTION);
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
1866 SetLastError(ERROR_INVALID_FUNCTION);
1867 return(FALSE);
1868}
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
1885 SetLastError(ERROR_INVALID_FUNCTION);
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
1905 SetLastError(ERROR_INVALID_FUNCTION);
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
1928 SetLastError(ERROR_INVALID_FUNCTION);
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
1950 SetLastError(ERROR_INVALID_FUNCTION);
1951 return WAIT_FAILED;
1952}
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
1970 SetLastError(ERROR_INVALID_FUNCTION);
1971 return FALSE;
1972}
1973
Note: See TracBrowser for help on using the repository browser.