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

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

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