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

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

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