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

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

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