source: trunk/src/kernel32/hmfile.cpp@ 9911

Last change on this file since 9911 was 9911, checked in by sandervl, 22 years ago

cleanup/resync
File size: 37.8 KB
Line 
1/* $Id: hmfile.cpp,v 1.41 2003-03-06 10:44:33 sandervl Exp $ */
2
3/*
4 * File IO win32 apis
5 *
6 * Copyright 1999-2000 Sander van Leeuwen
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13/*****************************************************************************
14 * Remark *
15 *****************************************************************************
16 */
17
18//#define DEBUG_LOCAL
19
20#ifdef DEBUG_LOCAL
21# define dprintfl(a) dprintf(a)
22#else
23inline void ignore_dprintf(...){}
24# define dprintfl(a) ignore_dprintf(a)
25#endif
26
27/*****************************************************************************
28 * Includes *
29 *****************************************************************************/
30
31#include <os2win.h>
32#include <string.h>
33#include "HandleManager.h"
34#include "HMFile.h"
35#include "mmap.h"
36#include "oslibdos.h"
37
38#define DBG_LOCALLOG DBG_hmfile
39#include "dbglocal.h"
40
41/*****************************************************************************
42 * Name : DWORD HMDeviceFileClass::CreateFile
43 * Purpose : this is called from the handle manager if a CreateFile() is
44 * performed on a handle
45 * Parameters: LPCSTR lpFileName name of the file / device
46 * PHMHANDLEDATA pHMHandleData data of the NEW handle
47 * PVOID lpSecurityAttributes ignored
48 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
49 * Variables :
50 * Result :
51 * Remark :
52 * Status : NO_ERROR - API succeeded
53 * other - what is to be set in SetLastError
54 *
55 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
56 *****************************************************************************/
57
58DWORD HMDeviceFileClass::CreateFile (LPCSTR lpFileName,
59 PHMHANDLEDATA pHMHandleData,
60 PVOID lpSecurityAttributes,
61 PHMHANDLEDATA pHMHandleDataTemplate)
62{
63 HFILE hFile;
64 HFILE hTemplate;
65 char filepath[260];
66
67 dprintfl(("KERNEL32: HMDeviceFileClass::CreateFile %s(%s,%08x,%08x,%08x)\n",
68 lpHMDeviceName,
69 lpFileName,
70 pHMHandleData,
71 lpSecurityAttributes,
72 pHMHandleDataTemplate));
73
74 ParsePath(lpFileName, filepath, sizeof(filepath));
75
76 //convert to long file name if in 8.3 hashed format
77 GetLongPathNameA(filepath, filepath, sizeof(filepath));
78 lpFileName = filepath;
79
80 // create from template
81 if (pHMHandleDataTemplate != NULL)
82 hTemplate = pHMHandleDataTemplate->hHMHandle;
83 else
84 hTemplate = 0;
85
86 //TODO: FILE_SHARE_DELETE
87 hFile = OSLibDosCreateFile((LPSTR)lpFileName,
88 pHMHandleData->dwAccess,
89 pHMHandleData->dwShare,
90 (LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
91 pHMHandleData->dwCreation,
92 pHMHandleData->dwFlags,
93 hTemplate);
94
95 if (hFile != INVALID_HANDLE_ERROR)
96 {
97 pHMHandleData->dwUserData = (DWORD) new HMFileInfo((LPSTR)lpFileName, lpSecurityAttributes);
98 pHMHandleData->hHMHandle = hFile;
99 return (NO_ERROR);
100 }
101 else {
102 dprintf(("CreateFile failed; error %d", GetLastError()));
103 return(GetLastError());
104 }
105}
106
107//*****************************************************************************
108//Parses and copies path
109//OpenFile in NT4, SP6 accepts double (or more) backslashes as separators for directories!
110//(OS/2 doesn't)
111//Girotel 2.0 (Dutch banking app) seems to depend on this behaviour
112//*****************************************************************************
113void HMDeviceFileClass::ParsePath(LPCSTR lpszFileName, LPSTR lpszParsedFileName, DWORD length)
114{
115 int i=0;
116
117 while(*lpszFileName != 0 && i < length-1) {
118 *lpszParsedFileName++ = *lpszFileName;
119 if(*lpszFileName == '\\') {
120 while(*lpszFileName == '\\') {
121 lpszFileName++;
122 }
123 }
124 else {
125 lpszFileName++;
126 }
127 i++;
128 }
129 *lpszParsedFileName = 0;
130}
131
132/*****************************************************************************
133 * Name : DWORD HMDeviceFileClass::OpenFile
134 * Purpose : this is called from the handle manager if a OpenFile() is
135 * performed on a handle
136 * Parameters: LPCSTR lpFileName name of the file / device
137 * PHMHANDLEDATA pHMHandleData data of the NEW handle
138 * PVOID lpSecurityAttributes ignored
139 * PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
140 * Variables :
141 * Result :
142 * Remark : TODO: Check if this implementation is complete and 100% correct
143 * UTC Time or Localtime ?
144 * GetFileTime is changed, Returns UTC-time yet !!!!!
145 * Status : NO_ERROR - API succeeded
146 * other - what is to be set in SetLastError
147 *
148 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
149 *****************************************************************************/
150
151DWORD HMDeviceFileClass::OpenFile (LPCSTR lpszFileName,
152 PHMHANDLEDATA pHMHandleData,
153 OFSTRUCT *pOFStruct,
154 UINT fuMode)
155{
156 HFILE hFile;
157 FILETIME filetime;
158 WORD filedatetime[2];
159 char filepath[260];
160 LPSTR lpFileName = (LPSTR)lpszFileName;
161
162 SetLastError(ERROR_SUCCESS);
163
164 //Re-open using name in OFSTRUCT
165 if(fuMode & OF_REOPEN)
166 lpFileName = (LPSTR)pOFStruct->szPathName;
167 else memset(pOFStruct, 0, sizeof(OFSTRUCT));
168
169 dprintf(("KERNEL32: HMDeviceFileClass::OpenFile %s(%s,%08x,%08x,%08x)", lpHMDeviceName,
170 lpFileName, pHMHandleData, pOFStruct, fuMode));
171
172 if(lpFileName == NULL) {
173 dprintf(("Invalid name (NULL)!"));
174 SetLastError(ERROR_INVALID_NAME);
175 return HFILE_ERROR;
176 }
177
178 if(!strchr(lpFileName, ':') && !strchr(lpFileName, '\\'))
179 {
180 //filename only; search for file in following order
181 //1: dir from which the app loaded
182 //2: current dir
183 //3: windows system dir
184 //4: windows dir
185 //5: dirs in path path environment variable
186 //SearchPath does exactly that
187 LPSTR filenameinpath;
188
189 if(SearchPathA(NULL, lpFileName, NULL, sizeof(filepath), filepath, &filenameinpath) == 0
190 && !(fuMode & OF_CREATE) )
191 {
192 pOFStruct->nErrCode = ERROR_FILE_NOT_FOUND;
193 SetLastError(ERROR_FILE_NOT_FOUND);
194 return HFILE_ERROR;
195 }
196 lpFileName = filepath;
197 }
198 else {
199 ParsePath(lpFileName, filepath, sizeof(filepath));
200
201 //convert to long file name if in 8.3 hashed format
202 GetLongPathNameA(filepath, filepath, sizeof(filepath));
203
204 lpFileName = filepath;
205 }
206
207 // filling OFSTRUCT
208 pOFStruct->cBytes = sizeof(OFSTRUCT);
209 pOFStruct->nErrCode = 0;
210 strncpy((char *)pOFStruct->szPathName, lpFileName, OFS_MAXPATHNAME);
211 pOFStruct->szPathName[OFS_MAXPATHNAME-1] = 0;
212
213 hFile = OSLibDosOpenFile((LPSTR)lpFileName, fuMode);
214
215 if(hFile != INVALID_HANDLE_ERROR)
216 {
217 //Needed for GetFileTime
218 pHMHandleData->hHMHandle = hFile;
219 GetFileTime(pHMHandleData,
220 NULL,
221 NULL,
222 &filetime );
223
224 /* UTC Time or Localtime ? GetFileTime Returns UTC-time yet ? !!!!! */
225 FileTimeToDosDateTime(&filetime,
226 &filedatetime[0],
227 &filedatetime[1] );
228 memcpy(pOFStruct->reserved, filedatetime, sizeof(pOFStruct->reserved));
229
230 if(fuMode & OF_DELETE)
231 {
232 OSLibDosClose(hFile);
233 OSLibDosDelete((LPSTR)lpFileName);
234 }
235 else
236 if(fuMode & OF_EXIST)
237 {
238 OSLibDosClose(hFile);
239 hFile = HFILE_ERROR;
240 }
241 if(fuMode & OF_PARSE)
242 {
243 CHAR drive[4];
244
245 drive[0] = pOFStruct->szPathName[0];
246 drive[1] = pOFStruct->szPathName[1];
247 drive[2] = pOFStruct->szPathName[2];
248 drive[3] = 0;
249
250 pOFStruct->fFixedDisk = (GetDriveTypeA(drive) != DRIVE_REMOVABLE);
251
252 OSLibDosClose(hFile);
253 hFile = HFILE_ERROR;
254 }
255
256 if((fuMode & OF_VERIFY))
257 {
258 if(memcmp(pOFStruct->reserved, filedatetime, sizeof(pOFStruct->reserved)))
259 {
260 OSLibDosClose(hFile);
261 SetLastError(ERROR_FILE_NOT_FOUND);
262 }
263 hFile = HFILE_ERROR;
264 }
265
266 pOFStruct->nErrCode = GetLastError();
267 pHMHandleData->hHMHandle = hFile;
268
269 if(hFile != HFILE_ERROR) {
270 pHMHandleData->dwUserData = (DWORD) new HMFileInfo((LPSTR)lpFileName, NULL);
271 }
272 return (NO_ERROR);
273 }
274 else {
275 DWORD rc = GetLastError();
276
277 if(fuMode & OF_EXIST)
278 {
279 if(rc == ERROR_OPEN_FAILED) {
280 SetLastError(ERROR_FILE_NOT_FOUND);
281 }
282 }
283 //todo: OF_PROMPT handling (pop up message box)
284 }
285 // error branch
286 pOFStruct->nErrCode = GetLastError();
287 dprintf(("KERNEL32: HMDeviceFileClass::OpenFile Error %08xh\n",
288 pOFStruct->nErrCode));
289
290 // return != NO_ERROR => error code
291 return(hFile);
292}
293
294/*****************************************************************************
295 * Name : HMDeviceFileClass::DuplicateHandle
296 * Purpose :
297 * Parameters:
298 * various parameters as required
299 * Variables :
300 * Result :
301 * Remark : DUPLICATE_CLOSE_SOURCE flag handled in HMDuplicateHandle
302 *
303 * Status : partially implemented
304 *
305 * Author : SvL
306 *****************************************************************************/
307BOOL HMDeviceFileClass::DuplicateHandle(HANDLE srchandle, PHMHANDLEDATA pHMHandleData,
308 HANDLE srcprocess,
309 PHMHANDLEDATA pHMSrcHandle,
310 HANDLE destprocess,
311 PHANDLE desthandle,
312 DWORD fdwAccess,
313 BOOL fInherit,
314 DWORD fdwOptions,
315 DWORD fdwOdinOptions)
316{
317 HMFileInfo *srcfileinfo = (HMFileInfo *)pHMSrcHandle->dwUserData;
318 DWORD rc;
319
320 dprintf(("KERNEL32:HMDeviceFileClass::DuplicateHandle (%08x,%08x,%08x,%08x,%08x)",
321 pHMHandleData,
322 srcprocess,
323 pHMSrcHandle->hHMHandle,
324 destprocess,
325 desthandle));
326
327 //TODO: Inheritance of file handles won't work!
328
329 if(destprocess != srcprocess)
330 {
331 //TODO:!!!!
332 dprintf(("ERROR: DuplicateHandle; different processes not yet supported!!"));
333 return FALSE;
334 }
335
336 if(srcfileinfo)
337 {
338 //SvL: Special duplicatehandle option used by memory mapped class to duplicate
339 // file handle
340 // Can't use DosDupHandle or else there can be a sharing violation
341 // when an app tries to access the same file again
342 if(fdwOdinOptions)
343 {
344 HMHANDLEDATA duphdata;
345
346 memcpy(&duphdata, pHMHandleData, sizeof(duphdata));
347 duphdata.dwCreation = OPEN_EXISTING;
348
349 if(CreateFile(srcfileinfo->lpszFileName, &duphdata,
350 srcfileinfo->lpSecurityAttributes, NULL) == NO_ERROR)
351 {
352 memcpy(pHMHandleData, &duphdata, sizeof(duphdata));
353
354 if(fInherit) SetHandleInformation(pHMHandleData, ~HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
355
356 SetLastError(ERROR_SUCCESS);
357 return TRUE;
358 }
359 dprintf(("ERROR: DuplicateHandle; CreateFile %s failed -> trying DosDupHandle instead!",
360 srcfileinfo->lpszFileName));
361 //SvL: IE5 setup opens file with DENYREADWRITE, so CreateFile can't
362 // be used for duplicating the handle; try DosDupHandle instead
363 }
364
365 if(!(fdwOptions & DUPLICATE_SAME_ACCESS) && fdwAccess != pHMSrcHandle->dwAccess) {
366 dprintf(("WARNING: DuplicateHandle; app wants different access permission; Not supported!! (%x, %x)", fdwAccess, pHMSrcHandle->dwAccess));
367 }
368
369 rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle,
370 desthandle);
371 if (rc)
372 {
373 dprintf(("ERROR: DuplicateHandle: OSLibDosDupHandle(%s) failed = %u",
374 srcfileinfo->lpszFileName, rc));
375 SetLastError(rc);
376 return FALSE; // ERROR
377 }
378 else {
379 if(fInherit) SetHandleInformation(pHMHandleData, ~HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
380
381 SetLastError(ERROR_SUCCESS);
382 pHMHandleData->hHMHandle = *desthandle;
383 return TRUE; // OK
384 }
385 }
386 else
387 {
388 dprintf(("ERROR: DuplicateHandle; invalid parameter!!"));
389 SetLastError(ERROR_INVALID_PARAMETER);
390 return FALSE;
391 }
392}
393
394/*****************************************************************************
395 * Name : BOOL HMDeviceFileClass::SetHandleInformation
396 * Purpose : The SetHandleInformation function sets certain properties of an
397 * object handle. The information is specified as a set of bit flags.
398 * Parameters: HANDLE hObject handle to an object
399 * DWORD dwMask specifies flags to change
400 * DWORD dwFlags specifies new values for flags
401 * Variables :
402 * Result : TRUE / FALSE
403 * Remark :
404 * Status :
405 *
406 * Author : SvL
407 *****************************************************************************/
408BOOL HMDeviceFileClass::SetHandleInformation(PHMHANDLEDATA pHMHandleData,
409 DWORD dwMask,
410 DWORD dwFlags)
411{
412 DWORD rc;
413
414 pHMHandleData->dwHandleInformation &= ~dwMask;
415 pHMHandleData->dwHandleInformation |= (dwFlags & dwMask);
416
417 rc = OSLibDosSetFHState(pHMHandleData->hHMHandle,
418 pHMHandleData->dwHandleInformation);
419 if (rc)
420 {
421 dprintf(("ERROR: SetHandleInformation: OSLibDosSetFHState failed with %d", rc));
422
423 SetLastError(rc);
424 return FALSE;
425 }
426
427 SetLastError(ERROR_SUCCESS);
428 return TRUE;
429}
430
431/*****************************************************************************
432 * Name : BOOL HMDeviceFileClass::CloseHandle
433 * Purpose : close the handle
434 * Parameters: PHMHANDLEDATA pHMHandleData
435 * Variables :
436 * Result : API returncode
437 * Remark :
438 * Status :
439 *
440 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
441 *****************************************************************************/
442
443BOOL HMDeviceFileClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
444{
445 HMFileInfo *fileInfo = (HMFileInfo *)pHMHandleData->dwUserData;
446 BOOL bRC;
447
448 dprintfl(("KERNEL32: HMDeviceFileClass::CloseHandle(%08x)\n",
449 pHMHandleData->hHMHandle));
450
451 bRC = OSLibDosClose(pHMHandleData->hHMHandle);
452
453 if(pHMHandleData->dwFlags & FILE_FLAG_DELETE_ON_CLOSE) {
454 //TODO: should only do this after all handles have been closed
455 if(fileInfo) {
456 DeleteFileA(fileInfo->lpszFileName);
457 }
458 }
459 if(fileInfo) {
460 delete fileInfo;
461 }
462 dprintf(("KERNEL32: HMDeviceFileClass::CloseHandle returned %08xh\n",
463 bRC));
464
465 return (DWORD)bRC;
466}
467
468
469/*****************************************************************************
470 * Name : BOOL HMDeviceFileClass::ReadFile
471 * Purpose : read data from handle / device
472 * Parameters: PHMHANDLEDATA pHMHandleData,
473 * LPCVOID lpBuffer,
474 * DWORD nNumberOfBytesToRead,
475 * LPDWORD lpNumberOfBytesRead,
476 * LPOVERLAPPED lpOverlapped
477 * Variables :
478 * Result : Boolean
479 * Remark :
480 * Status :
481 *
482 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
483 *****************************************************************************/
484
485BOOL HMDeviceFileClass::ReadFile(PHMHANDLEDATA pHMHandleData,
486 LPCVOID lpBuffer,
487 DWORD nNumberOfBytesToRead,
488 LPDWORD lpNumberOfBytesRead,
489 LPOVERLAPPED lpOverlapped,
490 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
491{
492 LPVOID lpRealBuf;
493 Win32MemMap *map;
494 DWORD offset, bytesread;
495 BOOL bRC;
496
497 dprintfl(("KERNEL32: HMDeviceFileClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
498 lpHMDeviceName,
499 pHMHandleData,
500 lpBuffer,
501 nNumberOfBytesToRead,
502 lpNumberOfBytesRead,
503 lpOverlapped));
504
505 //SvL: It's legal for this pointer to be NULL
506 if(lpNumberOfBytesRead)
507 *lpNumberOfBytesRead = 0;
508 else
509 lpNumberOfBytesRead = &bytesread;
510
511 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
512 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
513 SetLastError(ERROR_INVALID_PARAMETER);
514 return FALSE;
515 }
516 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
517 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
518 }
519 if(lpCompletionRoutine) {
520 dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
521 }
522
523 //SvL: DosRead doesn't like writing to memory addresses returned by
524 // DosAliasMem -> search for original memory mapped pointer and use
525 // that one + commit pages if not already present
526 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_WRITE);
527 if(map) {
528 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
529 DWORD nrpages = (nNumberOfBytesToRead+offset)/4096;
530 if((nNumberOfBytesToRead+offset) & 0xfff)
531 nrpages++;
532
533 map->commitRange((ULONG)lpBuffer, offset & ~0xfff, TRUE, nrpages);
534 map->Release();
535 }
536 else lpRealBuf = (LPVOID)lpBuffer;
537
538 //If this file is also used in a memory map somewhere, then we need
539 //to tell the map to flush all modified contents to disk right NOW
540 map = Win32MemMap::findMapByFile(pHMHandleData->hWin32Handle);
541 if(map) {
542 DWORD curpos = SetFilePointer(pHMHandleData, 0, NULL, FILE_CURRENT);
543
544 dprintf(("Flush memory maps to disk before reading!!"));
545 map->flushView(MMAP_FLUSHVIEW_ALL, curpos, nNumberOfBytesToRead);
546 }
547
548 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
549 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
550 }
551// else {
552 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
553 (PVOID)lpRealBuf,
554 nNumberOfBytesToRead,
555 lpNumberOfBytesRead);
556// }
557
558 if(bRC == 0) {
559 dprintf(("KERNEL32: HMDeviceFileClass::ReadFile returned %08xh %x\n",
560 bRC, GetLastError()));
561 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
562 }
563
564 return bRC;
565}
566
567
568/*****************************************************************************
569 * Name : BOOL HMDeviceFileClass::WriteFile
570 * Purpose : write data to handle / device
571 * Parameters: PHMHANDLEDATA pHMHandleData,
572 * LPCVOID lpBuffer,
573 * DWORD nNumberOfBytesToWrite,
574 * LPDWORD lpNumberOfBytesWritten,
575 * LPOVERLAPPED lpOverlapped
576 * Variables :
577 * Result : Boolean
578 * Remark :
579 * Status :
580 *
581 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
582 *****************************************************************************/
583
584BOOL HMDeviceFileClass::WriteFile(PHMHANDLEDATA pHMHandleData,
585 LPCVOID lpBuffer,
586 DWORD nNumberOfBytesToWrite,
587 LPDWORD lpNumberOfBytesWritten,
588 LPOVERLAPPED lpOverlapped,
589 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
590{
591 LPVOID lpRealBuf;
592 Win32MemMap *map;
593 DWORD offset, byteswritten;
594 BOOL bRC;
595
596 dprintfl(("KERNEL32: HMDeviceFileClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
597 lpHMDeviceName,
598 pHMHandleData,
599 lpBuffer,
600 nNumberOfBytesToWrite,
601 lpNumberOfBytesWritten,
602 lpOverlapped));
603
604 //SvL: It's legal for this pointer to be NULL
605 if(lpNumberOfBytesWritten)
606 *lpNumberOfBytesWritten = 0;
607 else
608 lpNumberOfBytesWritten = &byteswritten;
609
610 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
611 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
612 SetLastError(ERROR_INVALID_PARAMETER);
613 return FALSE;
614 }
615 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
616 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
617 }
618
619 //SvL: DosWrite doesn't like reading from memory addresses returned by
620 // DosAliasMem -> search for original memory mapped pointer and use
621 // that one + commit pages if not already present
622 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
623 if(map) {
624 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
625 DWORD nrpages = (nNumberOfBytesToWrite+offset)/4096;
626 if((nNumberOfBytesToWrite+offset) & 0xfff)
627 nrpages++;
628
629 map->commitRange((ULONG)lpBuffer, offset & ~0xfff, TRUE, nrpages);
630 map->Release();
631 }
632 else lpRealBuf = (LPVOID)lpBuffer;
633
634 //If this file is also used in a memory map somewhere, then we need
635 //to tell the map to flush all modified contents to disk right NOW
636 DWORD curfilepos;
637 map = Win32MemMap::findMapByFile(pHMHandleData->hWin32Handle);
638 if(map) {
639 curfilepos = SetFilePointer(pHMHandleData, 0, NULL, FILE_CURRENT);
640
641 dprintf(("Flush memory maps to disk before writing!!"));
642 map->flushView(MMAP_FLUSHVIEW_ALL, curfilepos, nNumberOfBytesToWrite);
643 }
644
645 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
646 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
647 }
648// else {
649 bRC = OSLibDosWrite(pHMHandleData->hHMHandle,
650 (PVOID)lpRealBuf,
651 nNumberOfBytesToWrite,
652 lpNumberOfBytesWritten);
653// }
654
655 if(map && bRC) {
656 dprintf(("Invalidate memory map after file writing!!"));
657 map->invalidatePages(curfilepos, *lpNumberOfBytesWritten);
658 }
659
660 dprintf(("KERNEL32: HMDeviceFileClass::WriteFile returned %08xh\n",
661 bRC));
662
663 return bRC;
664}
665
666
667/*****************************************************************************
668 * Name : DWORD HMDeviceFileClass::GetFileType
669 * Purpose : determine the handle type
670 * Parameters: PHMHANDLEDATA pHMHandleData
671 * Variables :
672 * Result : API returncode
673 * Remark :
674 * Status :
675 *
676 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
677 *****************************************************************************/
678
679DWORD HMDeviceFileClass::GetFileType(PHMHANDLEDATA pHMHandleData)
680{
681 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileType %s(%08x)\n",
682 lpHMDeviceName,
683 pHMHandleData));
684
685 return FILE_TYPE_DISK;
686}
687
688
689/*****************************************************************************
690 * Name : DWORD HMDeviceFileClass::GetFileInformationByHandle
691 * Purpose : determine the handle type
692 * Parameters: PHMHANDLEDATA pHMHandleData
693 * BY_HANDLE_FILE_INFORMATION* pHFI
694 * Variables :
695 * Result : API returncode
696 * Remark :
697 * Status :
698 *
699 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
700 *****************************************************************************/
701
702DWORD HMDeviceFileClass::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
703 BY_HANDLE_FILE_INFORMATION* pHFI)
704{
705 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileInformationByHandle %s(%08xh,%08xh)\n",
706 lpHMDeviceName, pHMHandleData, pHFI));
707
708 if(OSLibDosGetFileInformationByHandle(pHMHandleData->hHMHandle,
709 pHFI))
710 {
711 return TRUE;
712 }
713 dprintf(("GetFileInformationByHandle failed with error %d", GetLastError()));
714 return FALSE;
715
716}
717
718
719/*****************************************************************************
720 * Name : BOOL HMDeviceFileClass::SetEndOfFile
721 * Purpose : set end of file marker
722 * Parameters: PHMHANDLEDATA pHMHandleData
723 * Variables :
724 * Result : API returncode
725 * Remark :
726 * Status :
727 *
728 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
729 *****************************************************************************/
730
731BOOL HMDeviceFileClass::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
732{
733 dprintfl(("KERNEL32: HMDeviceFileClass::SetEndOfFile %s(%08xh)\n",
734 lpHMDeviceName,
735 pHMHandleData));
736
737 if(OSLibDosSetEndOfFile(pHMHandleData->hHMHandle)) {
738 return TRUE;
739 }
740 dprintf(("SetEndOfFile failed with error %d", GetLastError()));
741 return FALSE;
742}
743
744//******************************************************************************
745/*****************************************************************************
746 * Name : BOOL HMDeviceFileClass::SetFileTime
747 * Purpose : set file time
748 * Parameters: PHMHANDLEDATA pHMHandleData
749 * PFILETIME pFT1
750 * PFILETIME pFT2
751 * PFILETIME pFT3
752 * Variables :
753 * Result : API returncode
754 * Remark :
755 * Status :
756 *
757 * Author : Patrick Haller [Wed, 1999/06/17 20:44] mod. DT
758 *****************************************************************************/
759
760BOOL HMDeviceFileClass::SetFileTime(PHMHANDLEDATA pHMHandleData,
761 LPFILETIME pFT1,
762 LPFILETIME pFT2,
763 LPFILETIME pFT3)
764{
765 dprintfl(("KERNEL32: HMDeviceFileClass::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
766 lpHMDeviceName, pHMHandleData, pFT1, pFT2, pFT3));
767
768 if(OSLibDosSetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
769
770 dprintf(("SetFileTime failed with error %d", GetLastError()));
771 return FALSE;
772}
773
774/*****************************************************************************
775 * Name : BOOL HMDeviceFileClass::GetFileTime
776 * Purpose : get file time
777 * Parameters: PHMHANDLEDATA pHMHandleData
778 * PFILETIME pFT1
779 * PFILETIME pFT2
780 * PFILETIME pFT3
781 * Variables :
782 * Result : API returncode
783 * Remark :
784 * Status :
785 *
786 * Author : SvL mod. DT
787 *****************************************************************************/
788
789BOOL HMDeviceFileClass::GetFileTime(PHMHANDLEDATA pHMHandleData,
790 LPFILETIME pFT1,
791 LPFILETIME pFT2,
792 LPFILETIME pFT3)
793{
794 if(!pFT1 && !pFT2 && !pFT3) {//TODO: does NT do this?
795 dprintf(("ERROR: GetFileTime: invalid parameter!"));
796 SetLastError(ERROR_INVALID_PARAMETER);
797 return FALSE;
798 }
799
800 if(OSLibDosGetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
801 dprintf(("GetFileTime failed with error %d", GetLastError()));
802 return FALSE;
803}
804
805/*****************************************************************************
806 * Name : DWORD HMDeviceFileClass::GetFileSize
807 * Purpose : set file time
808 * Parameters: PHMHANDLEDATA pHMHandleData
809 * PDWORD pSize
810 * Variables :
811 * Result : API returncode
812 * Remark :
813 * Status :
814 *
815 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
816 *****************************************************************************/
817
818DWORD HMDeviceFileClass::GetFileSize(PHMHANDLEDATA pHMHandleData,
819 PDWORD lpdwFileSizeHigh)
820{
821 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileSize %s(%08xh,%08xh)\n",
822 lpHMDeviceName,
823 pHMHandleData,
824 lpdwFileSizeHigh));
825
826 if(lpdwFileSizeHigh)
827 *lpdwFileSizeHigh = 0;
828
829 return OSLibDosGetFileSize(pHMHandleData->hHMHandle, lpdwFileSizeHigh);
830}
831
832/*****************************************************************************
833 * Name : DWORD HMDeviceFileClass::SetFilePointer
834 * Purpose : set file pointer
835 * Parameters: PHMHANDLEDATA pHMHandleData
836 * LONG lDistanceToMove
837 * PLONG lpDistanceToMoveHigh
838 * DWORD dwMoveMethod
839 * Variables :
840 * Result : API returncode
841 * Remark :
842 * Status :
843 *
844 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
845 *****************************************************************************/
846
847DWORD HMDeviceFileClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
848 LONG lDistanceToMove,
849 PLONG lpDistanceToMoveHigh,
850 DWORD dwMoveMethod)
851{
852 DWORD ret;
853
854 dprintfl(("KERNEL32: HMDeviceFileClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
855 lpHMDeviceName,
856 pHMHandleData,
857 lDistanceToMove,
858 lpDistanceToMoveHigh,
859 dwMoveMethod));
860
861 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
862 lDistanceToMove,
863 (DWORD *)lpDistanceToMoveHigh,
864 dwMoveMethod);
865
866 if(ret == -1) {
867 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
868 }
869 return ret;
870}
871
872
873/*****************************************************************************
874 * Name : DWORD HMDeviceFileClass::LockFile
875 * Purpose : file locking
876 * Parameters: PHMHANDLEDATA pHMHandleData
877 * DWORD arg2
878 * DWORD arg3
879 * DWORD arg4
880 * DWORD arg5
881 * Variables :
882 * Result : API returncode
883 * Remark :
884 * Status :
885 *
886 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
887 *****************************************************************************/
888
889BOOL HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
890 DWORD dwFileOffsetLow,
891 DWORD dwFileOffsetHigh,
892 DWORD cbLockLow,
893 DWORD cbLockHigh)
894{
895 dprintfl(("KERNEL32: HMDeviceFileClass::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
896 lpHMDeviceName,
897 pHMHandleData,
898 dwFileOffsetLow,
899 dwFileOffsetHigh,
900 cbLockLow,
901 cbLockHigh));
902
903 return OSLibDosLockFile(pHMHandleData->hHMHandle,
904 LOCKFILE_EXCLUSIVE_LOCK,
905 dwFileOffsetLow,
906 dwFileOffsetHigh,
907 cbLockLow,
908 cbLockHigh,
909 NULL);
910}
911
912/*****************************************************************************
913 * Name : DWORD HMDeviceFileClass::LockFileEx
914 * Purpose : file locking
915 * Parameters: PHMHANDLEDATA pHMHandleData
916 * DWORD dwFlags
917 * DWORD dwReserved
918 * DWORD nNumberOfBytesToLockLow
919 * DWORD nNumberOfBytesToLockHigh
920 * LPOVERLAPPED lpOverlapped
921 * Variables :
922 * Result : API returncode
923 * Remark :
924 * Status :
925 *
926 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
927 *****************************************************************************/
928
929BOOL HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
930 DWORD dwFlags,
931 DWORD dwReserved,
932 DWORD nNumberOfBytesToLockLow,
933 DWORD nNumberOfBytesToLockHigh,
934 LPOVERLAPPED lpOverlapped)
935{
936
937 dprintfl(("KERNEL32: HMDeviceFileClass::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
938 lpHMDeviceName,
939 pHMHandleData,
940 dwFlags,
941 dwReserved,
942 nNumberOfBytesToLockLow,
943 nNumberOfBytesToLockHigh,
944 lpOverlapped));
945
946
947 return(OSLibDosLockFile(pHMHandleData->hHMHandle,
948 dwFlags,
949 lpOverlapped->Offset,
950 lpOverlapped->OffsetHigh,
951 nNumberOfBytesToLockLow,
952 nNumberOfBytesToLockHigh,
953 lpOverlapped));
954}
955
956
957/*****************************************************************************
958 * Name : DWORD HMDeviceFileClass::UnlockFile
959 * Purpose : file locking
960 * Parameters: PHMHANDLEDATA pHMHandleData
961 * DWORD arg2
962 * DWORD arg3
963 * DWORD arg4
964 * DWORD arg5
965 * Variables :
966 * Result : API returncode
967 * Remark :
968 * Status :
969 *
970 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
971 *****************************************************************************/
972
973BOOL HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
974 DWORD dwFileOffsetLow,
975 DWORD dwFileOffsetHigh,
976 DWORD cbLockLow,
977 DWORD cbLockHigh)
978{
979 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
980 lpHMDeviceName,
981 pHMHandleData,
982 dwFileOffsetLow,
983 dwFileOffsetHigh,
984 cbLockLow,
985 cbLockHigh));
986
987 return OSLibDosUnlockFile(pHMHandleData->hHMHandle,
988 dwFileOffsetLow,
989 dwFileOffsetHigh,
990 cbLockLow,
991 cbLockHigh,
992 NULL);
993}
994
995
996
997/*****************************************************************************
998 * Name : DWORD HMDeviceFileClass::UnlockFileEx
999 * Purpose : file locking
1000 * Parameters: PHMHANDLEDATA pHMHandleData
1001 * DWORD dwFlags
1002 * DWORD dwReserved
1003 * DWORD nNumberOfBytesToLockLow
1004 * DWORD nNumberOfBytesToLockHigh
1005 * LPOVERLAPPED lpOverlapped
1006 * Variables :
1007 * Result : API returncode
1008 * Remark :
1009 * Status :
1010 *
1011 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1012 *****************************************************************************/
1013
1014BOOL HMDeviceFileClass::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
1015 DWORD dwReserved,
1016 DWORD nNumberOfBytesToLockLow,
1017 DWORD nNumberOfBytesToLockHigh,
1018 LPOVERLAPPED lpOverlapped)
1019{
1020
1021 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
1022 lpHMDeviceName,
1023 pHMHandleData,
1024 dwReserved,
1025 nNumberOfBytesToLockLow,
1026 nNumberOfBytesToLockHigh,
1027 lpOverlapped));
1028
1029
1030 return(OSLibDosUnlockFile(pHMHandleData->hHMHandle,
1031 lpOverlapped->Offset,
1032 lpOverlapped->OffsetHigh,
1033 nNumberOfBytesToLockLow,
1034 nNumberOfBytesToLockHigh,
1035 lpOverlapped));
1036}
1037
1038
1039/*****************************************************************************
1040 * Name : DWORD HMDeviceFileClass::FlushFileBuffers
1041 * Purpose : flush the buffers of a file
1042 * Parameters: PHMHANDLEDATA pHMHandleData
1043 * Variables :
1044 * Result : API returncode
1045 * Remark :
1046 * Status :
1047 *
1048 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1049 *****************************************************************************/
1050
1051BOOL HMDeviceFileClass::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
1052{
1053 dprintfl(("KERNEL32: HMDeviceFileClass:FlushFileBuffers(%08xh)\n",
1054 pHMHandleData->hHMHandle));
1055
1056 return(OSLibDosFlushFileBuffers(pHMHandleData->hHMHandle));
1057}
1058
1059
1060/*****************************************************************************
1061 * Name : DWORD HMDeviceFileClass::GetOverlappedResult
1062 * Purpose : asynchronus I/O
1063 * Parameters: PHMHANDLEDATA pHMHandleData
1064 * LPOVERLAPPED arg2
1065 * LPDWORD arg3
1066 * BOOL arg4
1067 * Variables :
1068 * Result : API returncode
1069 * Remark :
1070 * Status :
1071 *
1072 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1073 *****************************************************************************/
1074
1075BOOL HMDeviceFileClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
1076 LPOVERLAPPED arg2,
1077 LPDWORD arg3,
1078 BOOL arg4)
1079{
1080 dprintfl(("KERNEL32-WARNING: HMDeviceFileClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
1081 pHMHandleData->hHMHandle,
1082 arg2,
1083 arg3,
1084 arg4));
1085
1086 return FALSE;
1087// return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
1088// arg2,
1089// arg3,
1090// arg4));
1091}
1092//******************************************************************************
1093//******************************************************************************
1094HMFileInfo::HMFileInfo(LPSTR lpszFileName, PVOID lpSecurityAttributes)
1095{
1096 this->lpszFileName = (LPSTR)malloc(strlen(lpszFileName)+1);
1097 if(!this->lpszFileName) {
1098 DebugInt3();
1099 }
1100 strcpy(this->lpszFileName, lpszFileName);
1101 this->lpSecurityAttributes = lpSecurityAttributes;
1102}
1103//******************************************************************************
1104//******************************************************************************
1105HMFileInfo::~HMFileInfo()
1106{
1107 if(lpszFileName) {
1108 free(lpszFileName);
1109 lpszFileName = NULL;
1110 }
1111}
1112//******************************************************************************
1113//******************************************************************************
Note: See TracBrowser for help on using the repository browser.