source: trunk/src/kernel32/hmopen32.cpp@ 375

Last change on this file since 375 was 278, checked in by phaller, 26 years ago

Add: HandleManager support for kernel objects, various fixes
File size: 25.3 KB
Line 
1/* $Id: hmopen32.cpp,v 1.8 1999-07-06 15:48:47 phaller Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 */
7
8
9/*****************************************************************************
10 * Remark *
11 *****************************************************************************
12 */
13
14//#define DEBUG_LOCAL
15
16#ifdef DEBUG_LOCAL
17# define dprintfl(a) dprintf(a)
18#else
19inline void ignore_dprintf(...){}
20# define dprintfl(a) ignore_dprintf(a)
21#endif
22
23/*****************************************************************************
24 * Includes *
25 *****************************************************************************/
26
27#include <os2win.h>
28#include <string.h>
29#include "HandleManager.h"
30#include "HMOpen32.h"
31
32
33/*****************************************************************************
34 * Defines *
35 *****************************************************************************/
36
37
38/*****************************************************************************
39 * Structures *
40 *****************************************************************************/
41
42/*****************************************************************************
43 * Name : HMDeviceOpen32Class::_DeviceRequest
44 * Purpose : entry method for special request functions
45 * Parameters: ULONG ulRequestCode
46 * various parameters as required
47 * Variables :
48 * Result :
49 * Remark : the standard behaviour is to return an error code for non-
50 * existant request codes
51 * Status :
52 *
53 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
54 *****************************************************************************/
55DWORD HMDeviceOpen32Class::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
56 ULONG ulRequestCode,
57 ULONG arg1,
58 ULONG arg2,
59 ULONG arg3,
60 ULONG arg4)
61{
62 dprintfl(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
63 lpHMDeviceName,
64 pHMHandleData,
65 ulRequestCode));
66
67 return(ERROR_INVALID_FUNCTION);
68}
69
70
71/*****************************************************************************
72 * Name : DWORD HMDeviceOpen32Class::CreateFile
73 * Purpose : this is called from the handle manager if a CreateFile() is
74 * performed on a handle
75 * Parameters: LPCSTR lpFileName name of the file / device
76 * PHMHANDLEDATA pHMHandleData data of the NEW handle
77 * PVOID lpSecurityAttributes ignored
78 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
79 * Variables :
80 * Result :
81 * Remark :
82 * Status : NO_ERROR - API succeeded
83 * other - what is to be set in SetLastError
84 *
85 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
86 *****************************************************************************/
87
88DWORD HMDeviceOpen32Class::CreateFile (LPCSTR lpFileName,
89 PHMHANDLEDATA pHMHandleData,
90 PVOID lpSecurityAttributes,
91 PHMHANDLEDATA pHMHandleDataTemplate)
92{
93 HFILE hFile;
94 HFILE hTemplate;
95
96 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
97 lpHMDeviceName,
98 lpFileName,
99 pHMHandleData,
100 lpSecurityAttributes,
101 pHMHandleDataTemplate));
102
103 if (strncmp(lpFileName, // "support" for local unc names
104 "\\\\.\\",
105 4) == 0)
106 lpFileName+=4;
107
108 // create from template
109 if (pHMHandleDataTemplate != NULL)
110 hTemplate = pHMHandleDataTemplate->hHMHandle;
111 else
112 hTemplate = 0;
113
114 hFile = O32_CreateFile(lpFileName,
115 pHMHandleData->dwAccess,
116 pHMHandleData->dwShare,
117 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
118 NULL,
119 pHMHandleData->dwCreation,
120 pHMHandleData->dwFlags,
121 hTemplate);
122 if (hFile != INVALID_HANDLE_ERROR)
123 {
124 pHMHandleData->hHMHandle = hFile;
125 return (NO_ERROR);
126 }
127 else
128 return(O32_GetLastError());
129}
130
131
132/*****************************************************************************
133 * Name : DWORD HMDeviceOpen32Class::CloseHandle
134 * Purpose : close the handle
135 * Parameters: PHMHANDLEDATA pHMHandleData
136 * Variables :
137 * Result : API returncode
138 * Remark :
139 * Status :
140 *
141 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
142 *****************************************************************************/
143
144DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
145{
146 BOOL bRC;
147
148 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
149 pHMHandleData->hHMHandle));
150
151 bRC = O32_CloseHandle(pHMHandleData->hHMHandle);
152
153 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
154 bRC));
155
156 return (DWORD)bRC;
157}
158
159
160/*****************************************************************************
161 * Name : DWORD HMDeviceOpen32Class::ReadFile
162 * Purpose : read data from handle / device
163 * Parameters: PHMHANDLEDATA pHMHandleData,
164 * LPCVOID lpBuffer,
165 * DWORD nNumberOfBytesToRead,
166 * LPDWORD lpNumberOfBytesRead,
167 * LPOVERLAPPED lpOverlapped
168 * Variables :
169 * Result : API returncode
170 * Remark :
171 * Status :
172 *
173 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
174 *****************************************************************************/
175
176DWORD HMDeviceOpen32Class::ReadFile(PHMHANDLEDATA pHMHandleData,
177 LPCVOID lpBuffer,
178 DWORD nNumberOfBytesToRead,
179 LPDWORD lpNumberOfBytesRead,
180 LPOVERLAPPED lpOverlapped)
181{
182 BOOL bRC;
183
184 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
185 lpHMDeviceName,
186 pHMHandleData,
187 lpBuffer,
188 nNumberOfBytesToRead,
189 lpNumberOfBytesRead,
190 lpOverlapped));
191
192 bRC = O32_ReadFile(pHMHandleData->hHMHandle,
193 (PVOID)lpBuffer,
194 nNumberOfBytesToRead,
195 lpNumberOfBytesRead,
196 lpOverlapped);
197
198 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
199 bRC));
200
201 return (DWORD)bRC;
202}
203
204
205/*****************************************************************************
206 * Name : DWORD HMDeviceOpen32Class::WriteFile
207 * Purpose : write data to handle / device
208 * Parameters: PHMHANDLEDATA pHMHandleData,
209 * LPCVOID lpBuffer,
210 * DWORD nNumberOfBytesToWrite,
211 * LPDWORD lpNumberOfBytesWritten,
212 * LPOVERLAPPED lpOverlapped
213 * Variables :
214 * Result : API returncode
215 * Remark :
216 * Status :
217 *
218 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
219 *****************************************************************************/
220
221DWORD HMDeviceOpen32Class::WriteFile(PHMHANDLEDATA pHMHandleData,
222 LPCVOID lpBuffer,
223 DWORD nNumberOfBytesToWrite,
224 LPDWORD lpNumberOfBytesWritten,
225 LPOVERLAPPED lpOverlapped)
226{
227 BOOL bRC;
228
229 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
230 lpHMDeviceName,
231 pHMHandleData,
232 lpBuffer,
233 nNumberOfBytesToWrite,
234 lpNumberOfBytesWritten,
235 lpOverlapped));
236
237 bRC = O32_WriteFile(pHMHandleData->hHMHandle,
238 lpBuffer,
239 nNumberOfBytesToWrite,
240 lpNumberOfBytesWritten,
241 lpOverlapped);
242
243 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
244 bRC));
245
246 return (DWORD)bRC;
247}
248
249
250/*****************************************************************************
251 * Name : DWORD HMDeviceOpen32Class::GetFileType
252 * Purpose : determine the handle type
253 * Parameters: PHMHANDLEDATA pHMHandleData
254 * Variables :
255 * Result : API returncode
256 * Remark :
257 * Status :
258 *
259 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
260 *****************************************************************************/
261
262DWORD HMDeviceOpen32Class::GetFileType(PHMHANDLEDATA pHMHandleData)
263{
264 dprintfl(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
265 lpHMDeviceName,
266 pHMHandleData));
267
268 return O32_GetFileType(pHMHandleData->hHMHandle);
269}
270
271
272/*****************************************************************************
273 * Name : DWORD HMDeviceOpen32Class::GetFileInformationByHandle
274 * Purpose : determine the handle type
275 * Parameters: PHMHANDLEDATA pHMHandleData
276 * BY_HANDLE_FILE_INFORMATION* pHFI
277 * Variables :
278 * Result : API returncode
279 * Remark :
280 * Status :
281 *
282 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
283 *****************************************************************************/
284
285DWORD HMDeviceOpen32Class::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
286 BY_HANDLE_FILE_INFORMATION* pHFI)
287{
288 dprintfl(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
289 lpHMDeviceName,
290 pHMHandleData,
291 pHFI));
292
293 return O32_GetFileInformationByHandle(pHMHandleData->hHMHandle,
294 pHFI);
295}
296
297
298/*****************************************************************************
299 * Name : BOOL HMDeviceOpen32Class::SetEndOfFile
300 * Purpose : set end of file marker
301 * Parameters: PHMHANDLEDATA pHMHandleData
302 * Variables :
303 * Result : API returncode
304 * Remark :
305 * Status :
306 *
307 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
308 *****************************************************************************/
309
310BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
311{
312 dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
313 lpHMDeviceName,
314 pHMHandleData));
315
316 return O32_SetEndOfFile(pHMHandleData->hHMHandle);
317}
318
319
320/*****************************************************************************
321 * Name : BOOL HMDeviceOpen32Class::SetFileTime
322 * Purpose : set file time
323 * Parameters: PHMHANDLEDATA pHMHandleData
324 * PFILETIME pFT1
325 * PFILETIME pFT2
326 * PFILETIME pFT3
327 * Variables :
328 * Result : API returncode
329 * Remark :
330 * Status :
331 *
332 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
333 *****************************************************************************/
334
335BOOL HMDeviceOpen32Class::SetFileTime(PHMHANDLEDATA pHMHandleData,
336 LPFILETIME pFT1,
337 LPFILETIME pFT2,
338 LPFILETIME pFT3)
339{
340 dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
341 lpHMDeviceName,
342 pHMHandleData,
343 pFT1,
344 pFT2,
345 pFT3));
346
347 return O32_SetFileTime(pHMHandleData->hHMHandle,
348 pFT1,
349 pFT2,
350 pFT3);
351}
352
353
354/*****************************************************************************
355 * Name : DWORD HMDeviceOpen32Class::GetFileSize
356 * Purpose : set file time
357 * Parameters: PHMHANDLEDATA pHMHandleData
358 * PDWORD pSize
359 * Variables :
360 * Result : API returncode
361 * Remark :
362 * Status :
363 *
364 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
365 *****************************************************************************/
366
367DWORD HMDeviceOpen32Class::GetFileSize(PHMHANDLEDATA pHMHandleData,
368 PDWORD pSize)
369{
370 dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
371 lpHMDeviceName,
372 pHMHandleData,
373 pSize));
374
375 return O32_GetFileSize(pHMHandleData->hHMHandle,
376 pSize);
377}
378
379
380/*****************************************************************************
381 * Name : DWORD HMDeviceOpen32Class::SetFilePointer
382 * Purpose : set file pointer
383 * Parameters: PHMHANDLEDATA pHMHandleData
384 * LONG lDistanceToMove
385 * PLONG lpDistanceToMoveHigh
386 * DWORD dwMoveMethod
387 * Variables :
388 * Result : API returncode
389 * Remark :
390 * Status :
391 *
392 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
393 *****************************************************************************/
394
395DWORD HMDeviceOpen32Class::SetFilePointer(PHMHANDLEDATA pHMHandleData,
396 LONG lDistanceToMove,
397 PLONG lpDistanceToMoveHigh,
398 DWORD dwMoveMethod)
399{
400 dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
401 lpHMDeviceName,
402 pHMHandleData,
403 lDistanceToMove,
404 lpDistanceToMoveHigh,
405 dwMoveMethod));
406
407 return O32_SetFilePointer(pHMHandleData->hHMHandle,
408 lDistanceToMove,
409 lpDistanceToMoveHigh,
410 dwMoveMethod);
411}
412
413
414/*****************************************************************************
415 * Name : DWORD HMDeviceOpen32Class::LockFile
416 * Purpose : file locking
417 * Parameters: PHMHANDLEDATA pHMHandleData
418 * DWORD arg2
419 * DWORD arg3
420 * DWORD arg4
421 * DWORD arg5
422 * Variables :
423 * Result : API returncode
424 * Remark :
425 * Status :
426 *
427 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
428 *****************************************************************************/
429
430DWORD HMDeviceOpen32Class::LockFile(PHMHANDLEDATA pHMHandleData,
431 DWORD arg2,
432 DWORD arg3,
433 DWORD arg4,
434 DWORD arg5)
435{
436 dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
437 lpHMDeviceName,
438 pHMHandleData,
439 arg2,
440 arg3,
441 arg4,
442 arg5));
443
444 return O32_LockFile(pHMHandleData->hHMHandle,
445 arg2,
446 arg3,
447 arg4,
448 arg5);
449}
450
451
452
453/*****************************************************************************
454 * Name : DWORD HMDeviceOpen32Class::LockFileEx
455 * Purpose : file locking
456 * Parameters: PHMHANDLEDATA pHMHandleData
457 * DWORD dwFlags
458 * DWORD dwReserved
459 * DWORD nNumberOfBytesToLockLow
460 * DWORD nNumberOfBytesToLockHigh
461 * LPOVERLAPPED lpOverlapped
462 * Variables :
463 * Result : API returncode
464 * Remark :
465 * Status :
466 *
467 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
468 *****************************************************************************/
469
470DWORD HMDeviceOpen32Class::LockFileEx(PHMHANDLEDATA pHMHandleData,
471 DWORD dwFlags,
472 DWORD dwReserved,
473 DWORD nNumberOfBytesToLockLow,
474 DWORD nNumberOfBytesToLockHigh,
475 LPOVERLAPPED lpOverlapped)
476{
477
478 dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
479 lpHMDeviceName,
480 pHMHandleData,
481 dwFlags,
482 dwReserved,
483 nNumberOfBytesToLockLow,
484 nNumberOfBytesToLockHigh,
485 lpOverlapped));
486
487
488 return(O32_LockFile(pHMHandleData->hHMHandle,
489 lpOverlapped->Offset,
490 lpOverlapped->OffsetHigh,
491 nNumberOfBytesToLockLow,
492 nNumberOfBytesToLockHigh));
493}
494
495
496/*****************************************************************************
497 * Name : DWORD HMDeviceOpen32Class::OpenFile
498 * Purpose : this is called from the handle manager if a OpenFile() is
499 * performed on a handle
500 * Parameters: LPCSTR lpFileName name of the file / device
501 * PHMHANDLEDATA pHMHandleData data of the NEW handle
502 * PVOID lpSecurityAttributes ignored
503 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
504 * Variables :
505 * Result :
506 * Remark :
507 * Status : NO_ERROR - API succeeded
508 * other - what is to be set in SetLastError
509 *
510 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
511 *****************************************************************************/
512
513DWORD HMDeviceOpen32Class::OpenFile (LPCSTR lpFileName,
514 PHMHANDLEDATA pHMHandleData,
515 OFSTRUCT *pOFStruct,
516 UINT arg3)
517{
518 HFILE hFile;
519 FILETIME filetime;
520 WORD filedatetime[2];
521
522 dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
523 lpHMDeviceName,
524 lpFileName,
525 pHMHandleData,
526 pOFStruct,
527 arg3));
528
529 if (strcmp(lpFileName, // "support" for local unc names
530 "\\\\.\\") == 0)
531 lpFileName+=4;
532
533 // filling OFSTRUCT
534 pOFStruct->cBytes = sizeof(OFSTRUCT);
535 pOFStruct->nErrCode = 0;
536
537 hFile = O32_OpenFile(lpFileName,
538 pOFStruct,
539 arg3);
540 if (hFile != INVALID_HANDLE_ERROR)
541 {
542 pHMHandleData->hHMHandle = hFile;
543
544 GetFileTime(hFile,
545 NULL,
546 NULL,
547 &filetime );
548 FileTimeToDosDateTime(&filetime,
549 &filedatetime[0],
550 &filedatetime[1] );
551 memcpy(pOFStruct->reserved,
552 filedatetime,
553 sizeof(pOFStruct->reserved) );
554
555 return (NO_ERROR);
556 }
557
558 // error branch
559 pOFStruct->nErrCode = O32_GetLastError();
560 dprintf(("KERNEL32: HandleManager::Open32::OpenFile Error %08xh\n",
561 pOFStruct->nErrCode));
562
563 // return != NO_ERROR => error code
564 return(hFile);
565}
566
567
568/*****************************************************************************
569 * Name : DWORD HMDeviceOpen32Class::UnlockFile
570 * Purpose : file locking
571 * Parameters: PHMHANDLEDATA pHMHandleData
572 * DWORD arg2
573 * DWORD arg3
574 * DWORD arg4
575 * DWORD arg5
576 * Variables :
577 * Result : API returncode
578 * Remark :
579 * Status :
580 *
581 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
582 *****************************************************************************/
583
584DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
585 DWORD arg2,
586 DWORD arg3,
587 DWORD arg4,
588 DWORD arg5)
589{
590 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
591 lpHMDeviceName,
592 pHMHandleData,
593 arg2,
594 arg3,
595 arg4,
596 arg5));
597
598 return O32_UnlockFile(pHMHandleData->hHMHandle,
599 arg2,
600 arg3,
601 arg4,
602 arg5);
603}
604
605
606
607/*****************************************************************************
608 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
609 * Purpose : file locking
610 * Parameters: PHMHANDLEDATA pHMHandleData
611 * DWORD dwFlags
612 * DWORD dwReserved
613 * DWORD nNumberOfBytesToLockLow
614 * DWORD nNumberOfBytesToLockHigh
615 * LPOVERLAPPED lpOverlapped
616 * Variables :
617 * Result : API returncode
618 * Remark :
619 * Status :
620 *
621 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
622 *****************************************************************************/
623
624DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
625 DWORD dwFlags,
626 DWORD dwReserved,
627 DWORD nNumberOfBytesToLockLow,
628 DWORD nNumberOfBytesToLockHigh,
629 LPOVERLAPPED lpOverlapped)
630{
631
632 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
633 lpHMDeviceName,
634 pHMHandleData,
635 dwFlags,
636 dwReserved,
637 nNumberOfBytesToLockLow,
638 nNumberOfBytesToLockHigh,
639 lpOverlapped));
640
641 return(O32_UnlockFile(pHMHandleData->hHMHandle,
642 lpOverlapped->Offset,
643 lpOverlapped->OffsetHigh,
644 nNumberOfBytesToLockLow,
645 nNumberOfBytesToLockHigh));
646}
647
648
649/*****************************************************************************
650 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject
651 * Purpose : object synchronization
652 * Parameters: PHMHANDLEDATA pHMHandleData
653 * DWORD dwTimeout
654 * Variables :
655 * Result : API returncode
656 * Remark :
657 * Status :
658 *
659 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
660 *****************************************************************************/
661
662DWORD HMDeviceOpen32Class::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
663 DWORD dwTimeout)
664{
665 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObject(%08xh,%08h)\n",
666 pHMHandleData->hHMHandle,
667 dwTimeout));
668
669 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
670 dwTimeout));
671}
672
673
674/*****************************************************************************
675 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
676 * Purpose : object synchronization
677 * Parameters: PHMHANDLEDATA pHMHandleData
678 * DWORD dwTimeout
679 * BOOL fAlertable
680 * Variables :
681 * Result : API returncode
682 * Remark :
683 * Status :
684 *
685 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
686 *****************************************************************************/
687
688DWORD HMDeviceOpen32Class::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
689 DWORD dwTimeout,
690 BOOL fAlertable)
691{
692 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
693 pHMHandleData->hHMHandle,
694 dwTimeout,
695 fAlertable));
696
697 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
698 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
699 dwTimeout));
700}
701
702
703/*****************************************************************************
704 * Name : DWORD HMDeviceOpen32Class::FlushFileBuffers
705 * Purpose : flush the buffers of a file
706 * Parameters: PHMHANDLEDATA pHMHandleData
707 * Variables :
708 * Result : API returncode
709 * Remark :
710 * Status :
711 *
712 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
713 *****************************************************************************/
714
715BOOL HMDeviceOpen32Class::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
716{
717 dprintfl(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
718 pHMHandleData->hHMHandle));
719
720 return(O32_FlushFileBuffers(pHMHandleData->hHMHandle));
721}
722
723
724/*****************************************************************************
725 * Name : DWORD HMDeviceOpen32Class::GetOverlappedResult
726 * Purpose : asynchronus I/O
727 * Parameters: PHMHANDLEDATA pHMHandleData
728 * LPOVERLAPPED arg2
729 * LPDWORD arg3
730 * BOOL arg4
731 * Variables :
732 * Result : API returncode
733 * Remark :
734 * Status :
735 *
736 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
737 *****************************************************************************/
738
739BOOL HMDeviceOpen32Class::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
740 LPOVERLAPPED arg2,
741 LPDWORD arg3,
742 BOOL arg4)
743{
744 dprintfl(("KERNEL32: HandleManager::Open32::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
745 pHMHandleData->hHMHandle,
746 arg2,
747 arg3,
748 arg4));
749
750 return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
751 arg2,
752 arg3,
753 arg4));
754}
755
Note: See TracBrowser for help on using the repository browser.