source: trunk/src/kernel32/old/hmopen32.cpp@ 4540

Last change on this file since 4540 was 955, checked in by sandervl, 26 years ago

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