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

Last change on this file since 3593 was 3593, checked in by sandervl, 25 years ago

some bugfixes + GetVolumeInformation rewrite
File size: 32.2 KB
Line 
1/* $Id: hmopen32.cpp,v 1.23 2000-05-23 18:45:12 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#define DBG_LOCALLOG DBG_hmopen32
34#include "dbglocal.h"
35
36/*****************************************************************************
37 * Defines *
38 *****************************************************************************/
39
40
41/*****************************************************************************
42 * Structures *
43 *****************************************************************************/
44
45/*****************************************************************************
46 * Name : HMDeviceOpen32Class::_DeviceRequest
47 * Purpose : entry method for special request functions
48 * Parameters: ULONG ulRequestCode
49 * various parameters as required
50 * Variables :
51 * Result :
52 * Remark : the standard behaviour is to return an error code for non-
53 * existant request codes
54 * Status :
55 *
56 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
57 *****************************************************************************/
58DWORD HMDeviceOpen32Class::_DeviceRequest (PHMHANDLEDATA pHMHandleData,
59 ULONG ulRequestCode,
60 ULONG arg1,
61 ULONG arg2,
62 ULONG arg3,
63 ULONG arg4)
64{
65 dprintfl(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
66 lpHMDeviceName,
67 pHMHandleData,
68 ulRequestCode));
69
70 return(ERROR_INVALID_FUNCTION);
71}
72
73
74/*****************************************************************************
75 * Name : HMDeviceHandler::DuplicateHandle
76 * Purpose : dummy version
77 * Parameters:
78 * various parameters as required
79 * Variables :
80 * Result :
81 * Remark : the standard behaviour is to return an error code for non-
82 * existant request codes
83 * Status :
84 *
85 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
86 *****************************************************************************/
87BOOL HMDeviceOpen32Class::DuplicateHandle(PHMHANDLEDATA pHMHandleData, HANDLE srcprocess,
88 PHMHANDLEDATA pHMSrcHandle,
89 HANDLE destprocess,
90 PHANDLE desthandle,
91 DWORD fdwAccess,
92 BOOL fInherit,
93 DWORD fdwOptions)
94{
95 BOOL rc;
96
97 dprintf(("KERNEL32:HandleManager::Open32::DuplicateHandle %s(%08x,%08x,%08x,%08x,%08x)\n",
98 lpHMDeviceName,
99 pHMHandleData,
100 srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle));
101
102#if 1
103 rc = O32_DuplicateHandle(srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle, fdwAccess, fInherit, fdwOptions);
104
105 if(rc == TRUE) {
106 pHMHandleData->hHMHandle = *desthandle;
107 return (NO_ERROR);
108 }
109 else return(O32_GetLastError());
110#else
111 rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle, desthandle);
112 if(rc == NO_ERROR)
113 {
114 pHMHandleData->hHMHandle = *desthandle;
115 return (NO_ERROR);
116 }
117 else
118 {
119 dprintfl(("KERNEL32: HandleManager::Open32::DuplicateHandle Error %d\n",rc));
120 O32_SetLastError(rc);
121 return(rc);
122 }
123#endif
124}
125
126/*****************************************************************************
127 * Name : DWORD HMDeviceOpen32Class::CreateFile
128 * Purpose : this is called from the handle manager if a CreateFile() is
129 * performed on a handle
130 * Parameters: LPCSTR lpFileName name of the file / device
131 * PHMHANDLEDATA pHMHandleData data of the NEW handle
132 * PVOID lpSecurityAttributes ignored
133 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
134 * Variables :
135 * Result :
136 * Remark :
137 * Status : NO_ERROR - API succeeded
138 * other - what is to be set in SetLastError
139 *
140 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
141 *****************************************************************************/
142
143DWORD HMDeviceOpen32Class::CreateFile (LPCSTR lpFileName,
144 PHMHANDLEDATA pHMHandleData,
145 PVOID lpSecurityAttributes,
146 PHMHANDLEDATA pHMHandleDataTemplate)
147{
148 HFILE hFile;
149 HFILE hTemplate;
150
151 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
152 lpHMDeviceName,
153 lpFileName,
154 pHMHandleData,
155 lpSecurityAttributes,
156 pHMHandleDataTemplate));
157
158 if (strncmp(lpFileName, // "support" for local unc names
159 "\\\\.\\",
160 4) == 0)
161 {
162 lpFileName+=4;
163 }
164
165 // create from template
166 if (pHMHandleDataTemplate != NULL)
167 hTemplate = pHMHandleDataTemplate->hHMHandle;
168 else
169 hTemplate = 0;
170
171#if 1
172 //SvL: Open32 doesn't like this flag
173 if(pHMHandleData->dwShare & FILE_SHARE_DELETE) {
174 pHMHandleData->dwShare &= ~FILE_SHARE_DELETE;
175 }
176
177 hFile = O32_CreateFile(lpFileName,
178 pHMHandleData->dwAccess,
179 pHMHandleData->dwShare,
180 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
181 NULL,
182 pHMHandleData->dwCreation,
183 pHMHandleData->dwFlags,
184 hTemplate);
185 if (hFile != INVALID_HANDLE_ERROR)
186 {
187 pHMHandleData->hHMHandle = hFile;
188 return (NO_ERROR);
189 }
190 else {
191 dprintf(("CreateFile failed; error %x", O32_GetLastError()));
192 return(O32_GetLastError());
193 }
194#else
195
196 rc = OSLibDosCreate((char *)lpFileName,
197 pHMHandleData->dwAccess,
198 pHMHandleData->dwShare,
199 //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
200 NULL,
201 pHMHandleData->dwCreation,
202 pHMHandleData->dwFlags,
203 hTemplate, &hFile);
204 if(rc)
205 {
206 dprintfl(("KERNEL32: HandleManager::Open32::CreateFile Error %d\n",rc));
207 O32_SetLastError(rc);
208 return(rc);
209 }
210 else
211 {
212 pHMHandleData->hHMHandle = hFile;
213 return (NO_ERROR);
214 }
215#endif
216}
217
218
219/*****************************************************************************
220 * Name : DWORD HMDeviceOpen32Class::CloseHandle
221 * Purpose : close the handle
222 * Parameters: PHMHANDLEDATA pHMHandleData
223 * Variables :
224 * Result : API returncode
225 * Remark :
226 * Status :
227 *
228 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
229 *****************************************************************************/
230
231DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
232{
233 BOOL bRC;
234
235 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
236 pHMHandleData->hHMHandle));
237
238#if 1
239 bRC = O32_CloseHandle(pHMHandleData->hHMHandle);
240
241 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
242 bRC));
243
244 return (DWORD)bRC;
245#else
246 bRC = OSLibDosClose(pHMHandleData->hHMHandle);
247 if(bRC)
248 {
249 dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle Error %d\n",bRC));
250 O32_SetLastError(bRC);
251 return TRUE; // MUTEX Problem
252 return FALSE;
253 }
254 else
255 {
256 return TRUE;
257 }
258#endif
259}
260
261
262/*****************************************************************************
263 * Name : BOOL HMDeviceOpen32Class::ReadFile
264 * Purpose : read data from handle / device
265 * Parameters: PHMHANDLEDATA pHMHandleData,
266 * LPCVOID lpBuffer,
267 * DWORD nNumberOfBytesToRead,
268 * LPDWORD lpNumberOfBytesRead,
269 * LPOVERLAPPED lpOverlapped
270 * Variables :
271 * Result : Boolean
272 * Remark :
273 * Status :
274 *
275 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
276 *****************************************************************************/
277
278BOOL HMDeviceOpen32Class::ReadFile(PHMHANDLEDATA pHMHandleData,
279 LPCVOID lpBuffer,
280 DWORD nNumberOfBytesToRead,
281 LPDWORD lpNumberOfBytesRead,
282 LPOVERLAPPED lpOverlapped)
283{
284 BOOL bRC;
285 LPVOID lpRealBuf;
286
287 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
288 lpHMDeviceName,
289 pHMHandleData,
290 lpBuffer,
291 nNumberOfBytesToRead,
292 lpNumberOfBytesRead,
293 lpOverlapped));
294
295#if 1
296 Win32MemMap *map;
297 DWORD offset;
298
299 //SvL: DosRead doesn't like writing to memory addresses returned by
300 // DosAliasMem -> search for original memory mapped pointer and use
301 // that one
302 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
303 if(map) {
304 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
305 DWORD nrpages = nNumberOfBytesToRead/4096;
306 if(offset & 0xfff)
307 nrpages++;
308 else
309 if(nNumberOfBytesToRead & 0xfff)
310 nrpages++;
311
312 map->commitPage(offset & ~0xfff, TRUE, nrpages);
313 }
314 else lpRealBuf = (LPVOID)lpBuffer;
315
316 bRC = O32_ReadFile(pHMHandleData->hHMHandle,
317 (PVOID)lpRealBuf,
318 nNumberOfBytesToRead,
319 lpNumberOfBytesRead,
320 lpOverlapped);
321
322 if(bRC == 0) {
323 dprintf(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh %x\n",
324 bRC, GetLastError()));
325 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
326 }
327 else dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
328 bRC));
329
330 return bRC;
331#else
332 rc = OSLibDosRead(pHMHandleData->hHMHandle,
333 (PVOID) lpBuffer,
334 nNumberOfBytesToRead,
335 lpNumberOfBytesRead);
336 if(rc)
337 {
338 dprintfl(("KERNEL32: HandleManager::Open32::ReadFile Error %d\n",rc));
339 O32_SetLastError(rc);
340 return FALSE;
341 }
342 else
343 {
344 return TRUE;
345 }
346#endif
347}
348
349
350/*****************************************************************************
351 * Name : BOOL HMDeviceOpen32Class::WriteFile
352 * Purpose : write data to handle / device
353 * Parameters: PHMHANDLEDATA pHMHandleData,
354 * LPCVOID lpBuffer,
355 * DWORD nNumberOfBytesToWrite,
356 * LPDWORD lpNumberOfBytesWritten,
357 * LPOVERLAPPED lpOverlapped
358 * Variables :
359 * Result : Boolean
360 * Remark :
361 * Status :
362 *
363 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
364 *****************************************************************************/
365
366BOOL HMDeviceOpen32Class::WriteFile(PHMHANDLEDATA pHMHandleData,
367 LPCVOID lpBuffer,
368 DWORD nNumberOfBytesToWrite,
369 LPDWORD lpNumberOfBytesWritten,
370 LPOVERLAPPED lpOverlapped)
371{
372 BOOL bRC;
373
374 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
375 lpHMDeviceName,
376 pHMHandleData,
377 lpBuffer,
378 nNumberOfBytesToWrite,
379 lpNumberOfBytesWritten,
380 lpOverlapped));
381
382#if 1
383 bRC = O32_WriteFile(pHMHandleData->hHMHandle,
384 lpBuffer,
385 nNumberOfBytesToWrite,
386 lpNumberOfBytesWritten,
387 lpOverlapped);
388
389 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
390 bRC));
391
392 return bRC;
393#else
394 rc = OSLibDosWrite(pHMHandleData->hHMHandle,
395 (PVOID) lpBuffer,
396 nNumberOfBytesToWrite,
397 lpNumberOfBytesWritten);
398 if(rc)
399 {
400 dprintfl(("KERNEL32: HandleManager::Open32::WriteFile Error %d\n",rc));
401 O32_SetLastError(rc);
402 return FALSE;
403 }
404 else
405 {
406 return TRUE;
407 }
408#endif
409}
410
411
412/*****************************************************************************
413 * Name : DWORD HMDeviceOpen32Class::GetFileType
414 * Purpose : determine the handle type
415 * Parameters: PHMHANDLEDATA pHMHandleData
416 * Variables :
417 * Result : API returncode
418 * Remark :
419 * Status :
420 *
421 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
422 *****************************************************************************/
423
424DWORD HMDeviceOpen32Class::GetFileType(PHMHANDLEDATA pHMHandleData)
425{
426 dprintfl(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
427 lpHMDeviceName,
428 pHMHandleData));
429
430#if 1
431 return O32_GetFileType(pHMHandleData->hHMHandle);
432#else
433 // TODO: FILE_TYPE_DISK
434 return FILE_TYPE_CHAR;
435#endif
436}
437
438
439/*****************************************************************************
440 * Name : DWORD HMDeviceOpen32Class::GetFileInformationByHandle
441 * Purpose : determine the handle type
442 * Parameters: PHMHANDLEDATA pHMHandleData
443 * BY_HANDLE_FILE_INFORMATION* pHFI
444 * Variables :
445 * Result : API returncode
446 * Remark :
447 * Status :
448 *
449 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
450 *****************************************************************************/
451
452DWORD HMDeviceOpen32Class::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
453 BY_HANDLE_FILE_INFORMATION* pHFI)
454{
455 dprintfl(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
456 lpHMDeviceName,
457 pHMHandleData,
458 pHFI));
459
460 return O32_GetFileInformationByHandle(pHMHandleData->hHMHandle,
461 pHFI);
462}
463
464
465/*****************************************************************************
466 * Name : BOOL HMDeviceOpen32Class::SetEndOfFile
467 * Purpose : set end of file marker
468 * Parameters: PHMHANDLEDATA pHMHandleData
469 * Variables :
470 * Result : API returncode
471 * Remark :
472 * Status :
473 *
474 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
475 *****************************************************************************/
476
477BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
478{
479 dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
480 lpHMDeviceName,
481 pHMHandleData));
482
483 return O32_SetEndOfFile(pHMHandleData->hHMHandle);
484}
485
486
487/*****************************************************************************
488 * Name : BOOL HMDeviceOpen32Class::SetFileTime
489 * Purpose : set file time
490 * Parameters: PHMHANDLEDATA pHMHandleData
491 * PFILETIME pFT1
492 * PFILETIME pFT2
493 * PFILETIME pFT3
494 * Variables :
495 * Result : API returncode
496 * Remark :
497 * Status :
498 *
499 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
500 *****************************************************************************/
501
502BOOL HMDeviceOpen32Class::SetFileTime(PHMHANDLEDATA pHMHandleData,
503 LPFILETIME pFT1,
504 LPFILETIME pFT2,
505 LPFILETIME pFT3)
506{
507 dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
508 lpHMDeviceName,
509 pHMHandleData,
510 pFT1,
511 pFT2,
512 pFT3));
513
514 return O32_SetFileTime(pHMHandleData->hHMHandle,
515 pFT1,
516 pFT2,
517 pFT3);
518}
519
520/*****************************************************************************
521 * Name : BOOL HMDeviceOpen32Class::GetFileTime
522 * Purpose : get file time
523 * Parameters: PHMHANDLEDATA pHMHandleData
524 * PFILETIME pFT1
525 * PFILETIME pFT2
526 * PFILETIME pFT3
527 * Variables :
528 * Result : API returncode
529 * Remark :
530 * Status :
531 *
532 * Author : SvL
533 *****************************************************************************/
534
535BOOL HMDeviceOpen32Class::GetFileTime(PHMHANDLEDATA pHMHandleData,
536 LPFILETIME pFT1,
537 LPFILETIME pFT2,
538 LPFILETIME pFT3)
539{
540 return O32_GetFileTime(pHMHandleData->hHMHandle,
541 pFT1,
542 pFT2,
543 pFT3);
544}
545
546
547/*****************************************************************************
548 * Name : DWORD HMDeviceOpen32Class::GetFileSize
549 * Purpose : set file time
550 * Parameters: PHMHANDLEDATA pHMHandleData
551 * PDWORD pSize
552 * Variables :
553 * Result : API returncode
554 * Remark :
555 * Status :
556 *
557 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
558 *****************************************************************************/
559
560DWORD HMDeviceOpen32Class::GetFileSize(PHMHANDLEDATA pHMHandleData,
561 PDWORD lpdwFileSizeHigh)
562{
563 dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
564 lpHMDeviceName,
565 pHMHandleData,
566 lpdwFileSizeHigh));
567
568#if 1
569 if(lpdwFileSizeHigh)
570 *lpdwFileSizeHigh = 0;
571
572 return O32_GetFileSize(pHMHandleData->hHMHandle,
573 lpdwFileSizeHigh);
574#else
575 size = OSLibDosGetFileSize(pHMHandleData->hHMHandle);
576 if(pSize)
577 *pSize = 0;
578 return size;
579#endif
580}
581
582
583/*****************************************************************************
584 * Name : DWORD HMDeviceOpen32Class::SetFilePointer
585 * Purpose : set file pointer
586 * Parameters: PHMHANDLEDATA pHMHandleData
587 * LONG lDistanceToMove
588 * PLONG lpDistanceToMoveHigh
589 * DWORD dwMoveMethod
590 * Variables :
591 * Result : API returncode
592 * Remark :
593 * Status :
594 *
595 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
596 *****************************************************************************/
597
598DWORD HMDeviceOpen32Class::SetFilePointer(PHMHANDLEDATA pHMHandleData,
599 LONG lDistanceToMove,
600 PLONG lpDistanceToMoveHigh,
601 DWORD dwMoveMethod)
602{
603 dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
604 lpHMDeviceName,
605 pHMHandleData,
606 lDistanceToMove,
607 lpDistanceToMoveHigh,
608 dwMoveMethod));
609
610#if 1
611 DWORD ret;
612
613 if(lpDistanceToMoveHigh)
614 *lpDistanceToMoveHigh = 0;
615
616 ret = O32_SetFilePointer(pHMHandleData->hHMHandle,
617 lDistanceToMove,
618 lpDistanceToMoveHigh,
619 dwMoveMethod);
620
621// if(ret == -1) {
622// dprintf(("current position %x (error = %x)", O32_SetFilePointer(pHMHandleData->hHMHandle,0, 0, 1), GetLastError()));
623// }
624 return ret;
625#else
626
627 if(lpDistanceToMoveHigh)
628 *lpDistanceToMoveHigh = 0;
629 pos = OSLibDosSetFilePtr2(pHMHandleData->hHMHandle, lDistanceToMove, dwMoveMethod);
630 return pos;
631#endif
632}
633
634
635/*****************************************************************************
636 * Name : DWORD HMDeviceOpen32Class::LockFile
637 * Purpose : file locking
638 * Parameters: PHMHANDLEDATA pHMHandleData
639 * DWORD arg2
640 * DWORD arg3
641 * DWORD arg4
642 * DWORD arg5
643 * Variables :
644 * Result : API returncode
645 * Remark :
646 * Status :
647 *
648 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
649 *****************************************************************************/
650
651DWORD HMDeviceOpen32Class::LockFile(PHMHANDLEDATA pHMHandleData,
652 DWORD arg2,
653 DWORD arg3,
654 DWORD arg4,
655 DWORD arg5)
656{
657 dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
658 lpHMDeviceName,
659 pHMHandleData,
660 arg2,
661 arg3,
662 arg4,
663 arg5));
664
665 return O32_LockFile(pHMHandleData->hHMHandle,
666 arg2,
667 arg3,
668 arg4,
669 arg5);
670}
671
672
673
674/*****************************************************************************
675 * Name : DWORD HMDeviceOpen32Class::LockFileEx
676 * Purpose : file locking
677 * Parameters: PHMHANDLEDATA pHMHandleData
678 * DWORD dwFlags
679 * DWORD dwReserved
680 * DWORD nNumberOfBytesToLockLow
681 * DWORD nNumberOfBytesToLockHigh
682 * LPOVERLAPPED lpOverlapped
683 * Variables :
684 * Result : API returncode
685 * Remark :
686 * Status :
687 *
688 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
689 *****************************************************************************/
690
691DWORD HMDeviceOpen32Class::LockFileEx(PHMHANDLEDATA pHMHandleData,
692 DWORD dwFlags,
693 DWORD dwReserved,
694 DWORD nNumberOfBytesToLockLow,
695 DWORD nNumberOfBytesToLockHigh,
696 LPOVERLAPPED lpOverlapped)
697{
698
699 dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
700 lpHMDeviceName,
701 pHMHandleData,
702 dwFlags,
703 dwReserved,
704 nNumberOfBytesToLockLow,
705 nNumberOfBytesToLockHigh,
706 lpOverlapped));
707
708
709 return(O32_LockFile(pHMHandleData->hHMHandle,
710 lpOverlapped->Offset,
711 lpOverlapped->OffsetHigh,
712 nNumberOfBytesToLockLow,
713 nNumberOfBytesToLockHigh));
714}
715
716
717/*****************************************************************************
718 * Name : DWORD HMDeviceOpen32Class::OpenFile
719 * Purpose : this is called from the handle manager if a OpenFile() is
720 * performed on a handle
721 * Parameters: LPCSTR lpFileName name of the file / device
722 * PHMHANDLEDATA pHMHandleData data of the NEW handle
723 * PVOID lpSecurityAttributes ignored
724 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
725 * Variables :
726 * Result :
727 * Remark :
728 * Status : NO_ERROR - API succeeded
729 * other - what is to be set in SetLastError
730 *
731 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
732 *****************************************************************************/
733
734DWORD HMDeviceOpen32Class::OpenFile (LPCSTR lpFileName,
735 PHMHANDLEDATA pHMHandleData,
736 OFSTRUCT *pOFStruct,
737 UINT fuMode)
738{
739 HFILE hFile;
740 FILETIME filetime;
741 WORD filedatetime[2];
742 char filepath[260];
743
744 dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
745 lpHMDeviceName,
746 lpFileName,
747 pHMHandleData,
748 pOFStruct,
749 fuMode));
750
751 if(strcmp(lpFileName, // "support" for local unc names
752 "\\\\.\\") == 0)
753 {
754 lpFileName+=4;
755 }
756 else
757 if(!strchr(lpFileName, ':') && !strchr(lpFileName, '\\'))
758 {
759 //filename only; search for file in following order
760 //1: dir from which the app loaded
761 //2: current dir
762 //3: windows system dir
763 //4: windows dir
764 //5: dirs in path path environment variable
765 //SearchPath does exactly that
766 LPSTR filenameinpath;
767
768 if(SearchPathA(NULL, lpFileName, NULL, sizeof(filepath), filepath, &filenameinpath) == 0
769 && !(fuMode & OF_CREATE) ) {
770 SetLastError(ERROR_FILE_NOT_FOUND);
771 return HFILE_ERROR;
772 }
773 lpFileName = filepath;
774 }
775 // filling OFSTRUCT
776 memset(pOFStruct, 0, sizeof(OFSTRUCT));
777 pOFStruct->cBytes = sizeof(OFSTRUCT);
778 pOFStruct->nErrCode = 0;
779 strncpy((char *)pOFStruct->szPathName, lpFileName, OFS_MAXPATHNAME - 1);
780
781 hFile = O32_OpenFile(lpFileName,
782 pOFStruct,
783 fuMode);
784 if (hFile != INVALID_HANDLE_ERROR)
785 {
786 pHMHandleData->hHMHandle = hFile;
787
788 GetFileTime(pHMHandleData,
789 NULL,
790 NULL,
791 &filetime );
792 FileTimeToDosDateTime(&filetime,
793 &filedatetime[0],
794 &filedatetime[1] );
795 memcpy(pOFStruct->reserved,
796 filedatetime,
797 sizeof(pOFStruct->reserved) );
798
799 return (NO_ERROR);
800 }
801
802 // error branch
803 pOFStruct->nErrCode = O32_GetLastError();
804 dprintf(("KERNEL32: HandleManager::Open32::OpenFile Error %08xh\n",
805 pOFStruct->nErrCode));
806
807 // return != NO_ERROR => error code
808 return(hFile);
809}
810
811
812/*****************************************************************************
813 * Name : DWORD HMDeviceOpen32Class::UnlockFile
814 * Purpose : file locking
815 * Parameters: PHMHANDLEDATA pHMHandleData
816 * DWORD arg2
817 * DWORD arg3
818 * DWORD arg4
819 * DWORD arg5
820 * Variables :
821 * Result : API returncode
822 * Remark :
823 * Status :
824 *
825 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
826 *****************************************************************************/
827
828DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
829 DWORD arg2,
830 DWORD arg3,
831 DWORD arg4,
832 DWORD arg5)
833{
834 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
835 lpHMDeviceName,
836 pHMHandleData,
837 arg2,
838 arg3,
839 arg4,
840 arg5));
841
842 return O32_UnlockFile(pHMHandleData->hHMHandle,
843 arg2,
844 arg3,
845 arg4,
846 arg5);
847}
848
849
850
851/*****************************************************************************
852 * Name : DWORD HMDeviceOpen32Class::UnlockFileEx
853 * Purpose : file locking
854 * Parameters: PHMHANDLEDATA pHMHandleData
855 * DWORD dwFlags
856 * DWORD dwReserved
857 * DWORD nNumberOfBytesToLockLow
858 * DWORD nNumberOfBytesToLockHigh
859 * LPOVERLAPPED lpOverlapped
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::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
869 DWORD dwFlags,
870 DWORD dwReserved,
871 DWORD nNumberOfBytesToLockLow,
872 DWORD nNumberOfBytesToLockHigh,
873 LPOVERLAPPED lpOverlapped)
874{
875
876 dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
877 lpHMDeviceName,
878 pHMHandleData,
879 dwFlags,
880 dwReserved,
881 nNumberOfBytesToLockLow,
882 nNumberOfBytesToLockHigh,
883 lpOverlapped));
884
885 return(O32_UnlockFile(pHMHandleData->hHMHandle,
886 lpOverlapped->Offset,
887 lpOverlapped->OffsetHigh,
888 nNumberOfBytesToLockLow,
889 nNumberOfBytesToLockHigh));
890}
891
892
893/*****************************************************************************
894 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObject
895 * Purpose : object synchronization
896 * Parameters: PHMHANDLEDATA pHMHandleData
897 * DWORD dwTimeout
898 * Variables :
899 * Result : API returncode
900 * Remark :
901 * Status :
902 *
903 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
904 *****************************************************************************/
905
906DWORD HMDeviceOpen32Class::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
907 DWORD dwTimeout)
908{
909 DWORD rc, starttime, endtime;
910
911 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObject(%08xh,%08h)\n",
912 pHMHandleData->hHMHandle,
913 dwTimeout));
914
915 if(dwTimeout) {
916 starttime = O32_GetCurrentTime();
917 }
918 rc = (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
919 dwTimeout));
920 if(dwTimeout) {
921 endtime = O32_GetCurrentTime();
922 dprintf(("KERNEL32: HandleManager::WaitForSingleObject %x delta = %x (rc=%x)", pHMHandleData->hHMHandle, endtime - starttime, rc));
923 }
924 else dprintf(("KERNEL32: HandleManager::WaitForSingleObject %x rc=%x", pHMHandleData->hHMHandle, rc));
925 return rc;
926}
927
928
929/*****************************************************************************
930 * Name : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
931 * Purpose : object synchronization
932 * Parameters: PHMHANDLEDATA pHMHandleData
933 * DWORD dwTimeout
934 * BOOL fAlertable
935 * Variables :
936 * Result : API returncode
937 * Remark :
938 * Status :
939 *
940 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
941 *****************************************************************************/
942
943DWORD HMDeviceOpen32Class::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
944 DWORD dwTimeout,
945 BOOL fAlertable)
946{
947 dprintfl(("KERNEL32: HandleManager::Open32::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
948 pHMHandleData->hHMHandle,
949 dwTimeout,
950 fAlertable));
951
952 //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
953 return (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
954 dwTimeout));
955}
956
957
958/*****************************************************************************
959 * Name : DWORD HMDeviceOpen32Class::FlushFileBuffers
960 * Purpose : flush the buffers of a file
961 * Parameters: PHMHANDLEDATA pHMHandleData
962 * Variables :
963 * Result : API returncode
964 * Remark :
965 * Status :
966 *
967 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
968 *****************************************************************************/
969
970BOOL HMDeviceOpen32Class::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
971{
972 dprintfl(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
973 pHMHandleData->hHMHandle));
974
975 return(O32_FlushFileBuffers(pHMHandleData->hHMHandle));
976}
977
978
979/*****************************************************************************
980 * Name : DWORD HMDeviceOpen32Class::GetOverlappedResult
981 * Purpose : asynchronus I/O
982 * Parameters: PHMHANDLEDATA pHMHandleData
983 * LPOVERLAPPED arg2
984 * LPDWORD arg3
985 * BOOL arg4
986 * Variables :
987 * Result : API returncode
988 * Remark :
989 * Status :
990 *
991 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
992 *****************************************************************************/
993
994BOOL HMDeviceOpen32Class::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
995 LPOVERLAPPED arg2,
996 LPDWORD arg3,
997 BOOL arg4)
998{
999 dprintfl(("KERNEL32: HandleManager::Open32::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
1000 pHMHandleData->hHMHandle,
1001 arg2,
1002 arg3,
1003 arg4));
1004
1005 return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
1006 arg2,
1007 arg3,
1008 arg4));
1009}
1010
Note: See TracBrowser for help on using the repository browser.