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

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

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