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

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

VT:Fix for OpenFile; fill in OFSTRUCT even if api fails
File size: 30.0 KB
Line 
1/* $Id: hmopen32.cpp,v 1.16 2000-02-12 10:43:50 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 : BOOL 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 : Boolean
262 * Remark :
263 * Status :
264 *
265 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
266 *****************************************************************************/
267
268BOOL 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 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 : BOOL 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 : Boolean
350 * Remark :
351 * Status :
352 *
353 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
354 *****************************************************************************/
355
356BOOL 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 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 memset(pOFStruct, 0, sizeof(OFSTRUCT));
713 pOFStruct->cBytes = sizeof(OFSTRUCT);
714 pOFStruct->nErrCode = 0;
715 strncpy((char *)pOFStruct->szPathName, lpFileName, OFS_MAXPATHNAME - 1);
716
717 hFile = O32_OpenFile(lpFileName,
718 pOFStruct,
719 arg3);
720 if (hFile != INVALID_HANDLE_ERROR)
721 {
722 pHMHandleData->hHMHandle = hFile;
723
724 GetFileTime(hFile,
725 NULL,
726 NULL,
727 &filetime );
728 FileTimeToDosDateTime(&filetime,
729 &filedatetime[0],
730 &filedatetime[1] );
731 memcpy(pOFStruct->reserved,
732 filedatetime,
733 sizeof(pOFStruct->reserved) );
734
735 return (NO_ERROR);
736 }
737
738 // error branch
739 pOFStruct->nErrCode = O32_GetLastError();
740 dprintf(("KERNEL32: HandleManager::Open32::OpenFile Error %08xh\n",
741 pOFStruct->nErrCode));
742
743 // return != NO_ERROR => error code
744 return(hFile);
745}
746
747
748/*****************************************************************************
749 * Name : DWORD HMDeviceOpen32Class::UnlockFile
750 * Purpose : file locking
751 * Parameters: PHMHANDLEDATA pHMHandleData
752 * DWORD arg2
753 * DWORD arg3
754 * DWORD arg4
755 * DWORD arg5
756 * Variables :
757 * Result : API returncode
758 * Remark :
759 * Status :
760 *
761 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
762 *****************************************************************************/
763
764DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
765 DWORD arg2,
766 DWORD arg3,
767 DWORD arg4,
768 DWORD arg5)
769{
770 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
771 lpHMDeviceName,
772 pHMHandleData,
773 arg2,
774 arg3,
775 arg4,
776 arg5));
777
778 return O32_UnlockFile(pHMHandleData->hHMHandle,
779 arg2,
780 arg3,
781 arg4,
782 arg5);
783}
784
785
786
787/*****************************************************************************
788 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
789 * Purpose : file locking
790 * Parameters: PHMHANDLEDATA pHMHandleData
791 * DWORD dwFlags
792 * DWORD dwReserved
793 * DWORD nNumberOfBytesToLockLow
794 * DWORD nNumberOfBytesToLockHigh
795 * LPOVERLAPPED lpOverlapped
796 * Variables :
797 * Result : API returncode
798 * Remark :
799 * Status :
800 *
801 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
802 *****************************************************************************/
803
804DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
805 DWORD dwFlags,
806 DWORD dwReserved,
807 DWORD nNumberOfBytesToLockLow,
808 DWORD nNumberOfBytesToLockHigh,
809 LPOVERLAPPED lpOverlapped)
810{
811
812 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
813 lpHMDeviceName,
814 pHMHandleData,
815 dwFlags,
816 dwReserved,
817 nNumberOfBytesToLockLow,
818 nNumberOfBytesToLockHigh,
819 lpOverlapped));
820
821 return(O32_UnlockFile(pHMHandleData->hHMHandle,
822 lpOverlapped->Offset,
823 lpOverlapped->OffsetHigh,
824 nNumberOfBytesToLockLow,
825 nNumberOfBytesToLockHigh));
826}
827
828
829/*****************************************************************************
830 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject
831 * Purpose : object synchronization
832 * Parameters: PHMHANDLEDATA pHMHandleData
833 * DWORD dwTimeout
834 * Variables :
835 * Result : API returncode
836 * Remark :
837 * Status :
838 *
839 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
840 *****************************************************************************/
841
842DWORD HMDeviceOpen32Class::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
843 DWORD dwTimeout)
844{
845 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObject(%08xh,%08h)\n",
846 pHMHandleData->hHMHandle,
847 dwTimeout));
848
849 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
850 dwTimeout));
851}
852
853
854/*****************************************************************************
855 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
856 * Purpose : object synchronization
857 * Parameters: PHMHANDLEDATA pHMHandleData
858 * DWORD dwTimeout
859 * BOOL fAlertable
860 * Variables :
861 * Result : API returncode
862 * Remark :
863 * Status :
864 *
865 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
866 *****************************************************************************/
867
868DWORD HMDeviceOpen32Class::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
869 DWORD dwTimeout,
870 BOOL fAlertable)
871{
872 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
873 pHMHandleData->hHMHandle,
874 dwTimeout,
875 fAlertable));
876
877 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
878 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
879 dwTimeout));
880}
881
882
883/*****************************************************************************
884 * Name : DWORD HMDeviceOpen32Class::FlushFileBuffers
885 * Purpose : flush the buffers of a file
886 * Parameters: PHMHANDLEDATA pHMHandleData
887 * Variables :
888 * Result : API returncode
889 * Remark :
890 * Status :
891 *
892 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
893 *****************************************************************************/
894
895BOOL HMDeviceOpen32Class::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
896{
897 dprintfl(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
898 pHMHandleData->hHMHandle));
899
900 return(O32_FlushFileBuffers(pHMHandleData->hHMHandle));
901}
902
903
904/*****************************************************************************
905 * Name : DWORD HMDeviceOpen32Class::GetOverlappedResult
906 * Purpose : asynchronus I/O
907 * Parameters: PHMHANDLEDATA pHMHandleData
908 * LPOVERLAPPED arg2
909 * LPDWORD arg3
910 * BOOL arg4
911 * Variables :
912 * Result : API returncode
913 * Remark :
914 * Status :
915 *
916 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
917 *****************************************************************************/
918
919BOOL HMDeviceOpen32Class::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
920 LPOVERLAPPED arg2,
921 LPDWORD arg3,
922 BOOL arg4)
923{
924 dprintfl(("KERNEL32: HandleManager::Open32::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
925 pHMHandleData->hHMHandle,
926 arg2,
927 arg3,
928 arg4));
929
930 return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
931 arg2,
932 arg3,
933 arg4));
934}
935
Note: See TracBrowser for help on using the repository browser.