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

Last change on this file since 9824 was 9824, checked in by sandervl, 23 years ago

Cleaned up memory map code
File size: 36.8 KB
Line 
1/* $Id: hmfile.cpp,v 1.40 2003-02-18 18:48:54 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/4096;
530 if(offset & 0xfff)
531 nrpages++;
532 if(nNumberOfBytesToRead & 0xfff)
533 nrpages++;
534
535 map->commitPage(offset & ~0xfff, TRUE, nrpages);
536 map->Release();
537 }
538 else lpRealBuf = (LPVOID)lpBuffer;
539
540 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
541 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
542 }
543// else {
544 bRC = OSLibDosRead(pHMHandleData->hHMHandle,
545 (PVOID)lpRealBuf,
546 nNumberOfBytesToRead,
547 lpNumberOfBytesRead);
548// }
549
550 if(bRC == 0) {
551 dprintf(("KERNEL32: HMDeviceFileClass::ReadFile returned %08xh %x\n",
552 bRC, GetLastError()));
553 dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
554 }
555
556 return bRC;
557}
558
559
560/*****************************************************************************
561 * Name : BOOL HMDeviceFileClass::WriteFile
562 * Purpose : write data to handle / device
563 * Parameters: PHMHANDLEDATA pHMHandleData,
564 * LPCVOID lpBuffer,
565 * DWORD nNumberOfBytesToWrite,
566 * LPDWORD lpNumberOfBytesWritten,
567 * LPOVERLAPPED lpOverlapped
568 * Variables :
569 * Result : Boolean
570 * Remark :
571 * Status :
572 *
573 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
574 *****************************************************************************/
575
576BOOL HMDeviceFileClass::WriteFile(PHMHANDLEDATA pHMHandleData,
577 LPCVOID lpBuffer,
578 DWORD nNumberOfBytesToWrite,
579 LPDWORD lpNumberOfBytesWritten,
580 LPOVERLAPPED lpOverlapped,
581 LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
582{
583 LPVOID lpRealBuf;
584 Win32MemMap *map;
585 DWORD offset, byteswritten;
586 BOOL bRC;
587
588 dprintfl(("KERNEL32: HMDeviceFileClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
589 lpHMDeviceName,
590 pHMHandleData,
591 lpBuffer,
592 nNumberOfBytesToWrite,
593 lpNumberOfBytesWritten,
594 lpOverlapped));
595
596 //SvL: It's legal for this pointer to be NULL
597 if(lpNumberOfBytesWritten)
598 *lpNumberOfBytesWritten = 0;
599 else
600 lpNumberOfBytesWritten = &byteswritten;
601
602 if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
603 dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
604 SetLastError(ERROR_INVALID_PARAMETER);
605 return FALSE;
606 }
607 if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
608 dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
609 }
610
611 //SvL: DosWrite doesn't like reading from memory addresses returned by
612 // DosAliasMem -> search for original memory mapped pointer and use
613 // that one + commit pages if not already present
614 map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
615 if(map) {
616 lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
617 DWORD nrpages = nNumberOfBytesToWrite/4096;
618 if(offset & 0xfff)
619 nrpages++;
620 if(nNumberOfBytesToWrite & 0xfff)
621 nrpages++;
622
623 map->commitPage(offset & ~0xfff, TRUE, nrpages);
624 map->Release();
625 }
626 else lpRealBuf = (LPVOID)lpBuffer;
627
628 if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
629 dprintf(("ERROR: Overlapped IO not yet implememented!!"));
630 }
631// else {
632 bRC = OSLibDosWrite(pHMHandleData->hHMHandle,
633 (PVOID)lpRealBuf,
634 nNumberOfBytesToWrite,
635 lpNumberOfBytesWritten);
636// }
637
638 dprintf(("KERNEL32: HMDeviceFileClass::WriteFile returned %08xh\n",
639 bRC));
640
641 return bRC;
642}
643
644
645/*****************************************************************************
646 * Name : DWORD HMDeviceFileClass::GetFileType
647 * Purpose : determine the handle type
648 * Parameters: PHMHANDLEDATA pHMHandleData
649 * Variables :
650 * Result : API returncode
651 * Remark :
652 * Status :
653 *
654 * Author : Patrick Haller [Wed, 1998/02/11 20:44]
655 *****************************************************************************/
656
657DWORD HMDeviceFileClass::GetFileType(PHMHANDLEDATA pHMHandleData)
658{
659 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileType %s(%08x)\n",
660 lpHMDeviceName,
661 pHMHandleData));
662
663 return FILE_TYPE_DISK;
664}
665
666
667/*****************************************************************************
668 * Name : DWORD HMDeviceFileClass::GetFileInformationByHandle
669 * Purpose : determine the handle type
670 * Parameters: PHMHANDLEDATA pHMHandleData
671 * BY_HANDLE_FILE_INFORMATION* pHFI
672 * Variables :
673 * Result : API returncode
674 * Remark :
675 * Status :
676 *
677 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
678 *****************************************************************************/
679
680DWORD HMDeviceFileClass::GetFileInformationByHandle(PHMHANDLEDATA pHMHandleData,
681 BY_HANDLE_FILE_INFORMATION* pHFI)
682{
683 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileInformationByHandle %s(%08xh,%08xh)\n",
684 lpHMDeviceName, pHMHandleData, pHFI));
685
686 if(OSLibDosGetFileInformationByHandle(pHMHandleData->hHMHandle,
687 pHFI))
688 {
689 return TRUE;
690 }
691 dprintf(("GetFileInformationByHandle failed with error %d", GetLastError()));
692 return FALSE;
693
694}
695
696
697/*****************************************************************************
698 * Name : BOOL HMDeviceFileClass::SetEndOfFile
699 * Purpose : set end of file marker
700 * Parameters: PHMHANDLEDATA pHMHandleData
701 * Variables :
702 * Result : API returncode
703 * Remark :
704 * Status :
705 *
706 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
707 *****************************************************************************/
708
709BOOL HMDeviceFileClass::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
710{
711 dprintfl(("KERNEL32: HMDeviceFileClass::SetEndOfFile %s(%08xh)\n",
712 lpHMDeviceName,
713 pHMHandleData));
714
715 if(OSLibDosSetEndOfFile(pHMHandleData->hHMHandle)) {
716 return TRUE;
717 }
718 dprintf(("SetEndOfFile failed with error %d", GetLastError()));
719 return FALSE;
720}
721
722//******************************************************************************
723/*****************************************************************************
724 * Name : BOOL HMDeviceFileClass::SetFileTime
725 * Purpose : set file time
726 * Parameters: PHMHANDLEDATA pHMHandleData
727 * PFILETIME pFT1
728 * PFILETIME pFT2
729 * PFILETIME pFT3
730 * Variables :
731 * Result : API returncode
732 * Remark :
733 * Status :
734 *
735 * Author : Patrick Haller [Wed, 1999/06/17 20:44] mod. DT
736 *****************************************************************************/
737
738BOOL HMDeviceFileClass::SetFileTime(PHMHANDLEDATA pHMHandleData,
739 LPFILETIME pFT1,
740 LPFILETIME pFT2,
741 LPFILETIME pFT3)
742{
743 dprintfl(("KERNEL32: HMDeviceFileClass::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
744 lpHMDeviceName, pHMHandleData, pFT1, pFT2, pFT3));
745
746 if(OSLibDosSetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
747
748 dprintf(("SetFileTime failed with error %d", GetLastError()));
749 return FALSE;
750}
751
752/*****************************************************************************
753 * Name : BOOL HMDeviceFileClass::GetFileTime
754 * Purpose : get file time
755 * Parameters: PHMHANDLEDATA pHMHandleData
756 * PFILETIME pFT1
757 * PFILETIME pFT2
758 * PFILETIME pFT3
759 * Variables :
760 * Result : API returncode
761 * Remark :
762 * Status :
763 *
764 * Author : SvL mod. DT
765 *****************************************************************************/
766
767BOOL HMDeviceFileClass::GetFileTime(PHMHANDLEDATA pHMHandleData,
768 LPFILETIME pFT1,
769 LPFILETIME pFT2,
770 LPFILETIME pFT3)
771{
772 if(!pFT1 && !pFT2 && !pFT3) {//TODO: does NT do this?
773 dprintf(("ERROR: GetFileTime: invalid parameter!"));
774 SetLastError(ERROR_INVALID_PARAMETER);
775 return FALSE;
776 }
777
778 if(OSLibDosGetFileTime(pHMHandleData->hHMHandle, pFT1, pFT2, pFT3)) return TRUE;
779 dprintf(("GetFileTime failed with error %d", GetLastError()));
780 return FALSE;
781}
782
783/*****************************************************************************
784 * Name : DWORD HMDeviceFileClass::GetFileSize
785 * Purpose : set file time
786 * Parameters: PHMHANDLEDATA pHMHandleData
787 * PDWORD pSize
788 * Variables :
789 * Result : API returncode
790 * Remark :
791 * Status :
792 *
793 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
794 *****************************************************************************/
795
796DWORD HMDeviceFileClass::GetFileSize(PHMHANDLEDATA pHMHandleData,
797 PDWORD lpdwFileSizeHigh)
798{
799 dprintfl(("KERNEL32: HMDeviceFileClass::GetFileSize %s(%08xh,%08xh)\n",
800 lpHMDeviceName,
801 pHMHandleData,
802 lpdwFileSizeHigh));
803
804 if(lpdwFileSizeHigh)
805 *lpdwFileSizeHigh = 0;
806
807 return OSLibDosGetFileSize(pHMHandleData->hHMHandle, lpdwFileSizeHigh);
808}
809
810/*****************************************************************************
811 * Name : DWORD HMDeviceFileClass::SetFilePointer
812 * Purpose : set file pointer
813 * Parameters: PHMHANDLEDATA pHMHandleData
814 * LONG lDistanceToMove
815 * PLONG lpDistanceToMoveHigh
816 * DWORD dwMoveMethod
817 * Variables :
818 * Result : API returncode
819 * Remark :
820 * Status :
821 *
822 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
823 *****************************************************************************/
824
825DWORD HMDeviceFileClass::SetFilePointer(PHMHANDLEDATA pHMHandleData,
826 LONG lDistanceToMove,
827 PLONG lpDistanceToMoveHigh,
828 DWORD dwMoveMethod)
829{
830 DWORD ret;
831
832 dprintfl(("KERNEL32: HMDeviceFileClass::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
833 lpHMDeviceName,
834 pHMHandleData,
835 lDistanceToMove,
836 lpDistanceToMoveHigh,
837 dwMoveMethod));
838
839 ret = OSLibDosSetFilePointer(pHMHandleData->hHMHandle,
840 lDistanceToMove,
841 (DWORD *)lpDistanceToMoveHigh,
842 dwMoveMethod);
843
844 if(ret == -1) {
845 dprintf(("SetFilePointer failed (error = %d)", GetLastError()));
846 }
847 return ret;
848}
849
850
851/*****************************************************************************
852 * Name : DWORD HMDeviceFileClass::LockFile
853 * Purpose : file locking
854 * Parameters: PHMHANDLEDATA pHMHandleData
855 * DWORD arg2
856 * DWORD arg3
857 * DWORD arg4
858 * DWORD arg5
859 * Variables :
860 * Result : API returncode
861 * Remark :
862 * Status :
863 *
864 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
865 *****************************************************************************/
866
867BOOL HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
868 DWORD dwFileOffsetLow,
869 DWORD dwFileOffsetHigh,
870 DWORD cbLockLow,
871 DWORD cbLockHigh)
872{
873 dprintfl(("KERNEL32: HMDeviceFileClass::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
874 lpHMDeviceName,
875 pHMHandleData,
876 dwFileOffsetLow,
877 dwFileOffsetHigh,
878 cbLockLow,
879 cbLockHigh));
880
881 return OSLibDosLockFile(pHMHandleData->hHMHandle,
882 LOCKFILE_EXCLUSIVE_LOCK,
883 dwFileOffsetLow,
884 dwFileOffsetHigh,
885 cbLockLow,
886 cbLockHigh,
887 NULL);
888}
889
890/*****************************************************************************
891 * Name : DWORD HMDeviceFileClass::LockFileEx
892 * Purpose : file locking
893 * Parameters: PHMHANDLEDATA pHMHandleData
894 * DWORD dwFlags
895 * DWORD dwReserved
896 * DWORD nNumberOfBytesToLockLow
897 * DWORD nNumberOfBytesToLockHigh
898 * LPOVERLAPPED lpOverlapped
899 * Variables :
900 * Result : API returncode
901 * Remark :
902 * Status :
903 *
904 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
905 *****************************************************************************/
906
907BOOL HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
908 DWORD dwFlags,
909 DWORD dwReserved,
910 DWORD nNumberOfBytesToLockLow,
911 DWORD nNumberOfBytesToLockHigh,
912 LPOVERLAPPED lpOverlapped)
913{
914
915 dprintfl(("KERNEL32: HMDeviceFileClass::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
916 lpHMDeviceName,
917 pHMHandleData,
918 dwFlags,
919 dwReserved,
920 nNumberOfBytesToLockLow,
921 nNumberOfBytesToLockHigh,
922 lpOverlapped));
923
924
925 return(OSLibDosLockFile(pHMHandleData->hHMHandle,
926 dwFlags,
927 lpOverlapped->Offset,
928 lpOverlapped->OffsetHigh,
929 nNumberOfBytesToLockLow,
930 nNumberOfBytesToLockHigh,
931 lpOverlapped));
932}
933
934
935/*****************************************************************************
936 * Name : DWORD HMDeviceFileClass::UnlockFile
937 * Purpose : file locking
938 * Parameters: PHMHANDLEDATA pHMHandleData
939 * DWORD arg2
940 * DWORD arg3
941 * DWORD arg4
942 * DWORD arg5
943 * Variables :
944 * Result : API returncode
945 * Remark :
946 * Status :
947 *
948 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
949 *****************************************************************************/
950
951BOOL HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
952 DWORD dwFileOffsetLow,
953 DWORD dwFileOffsetHigh,
954 DWORD cbLockLow,
955 DWORD cbLockHigh)
956{
957 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
958 lpHMDeviceName,
959 pHMHandleData,
960 dwFileOffsetLow,
961 dwFileOffsetHigh,
962 cbLockLow,
963 cbLockHigh));
964
965 return OSLibDosUnlockFile(pHMHandleData->hHMHandle,
966 dwFileOffsetLow,
967 dwFileOffsetHigh,
968 cbLockLow,
969 cbLockHigh,
970 NULL);
971}
972
973
974
975/*****************************************************************************
976 * Name : DWORD HMDeviceFileClass::UnlockFileEx
977 * Purpose : file locking
978 * Parameters: PHMHANDLEDATA pHMHandleData
979 * DWORD dwFlags
980 * DWORD dwReserved
981 * DWORD nNumberOfBytesToLockLow
982 * DWORD nNumberOfBytesToLockHigh
983 * LPOVERLAPPED lpOverlapped
984 * Variables :
985 * Result : API returncode
986 * Remark :
987 * Status :
988 *
989 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
990 *****************************************************************************/
991
992BOOL HMDeviceFileClass::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
993 DWORD dwReserved,
994 DWORD nNumberOfBytesToLockLow,
995 DWORD nNumberOfBytesToLockHigh,
996 LPOVERLAPPED lpOverlapped)
997{
998
999 dprintfl(("KERNEL32: HMDeviceFileClass::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh) not completely implemented!",
1000 lpHMDeviceName,
1001 pHMHandleData,
1002 dwReserved,
1003 nNumberOfBytesToLockLow,
1004 nNumberOfBytesToLockHigh,
1005 lpOverlapped));
1006
1007
1008 return(OSLibDosUnlockFile(pHMHandleData->hHMHandle,
1009 lpOverlapped->Offset,
1010 lpOverlapped->OffsetHigh,
1011 nNumberOfBytesToLockLow,
1012 nNumberOfBytesToLockHigh,
1013 lpOverlapped));
1014}
1015
1016
1017/*****************************************************************************
1018 * Name : DWORD HMDeviceFileClass::FlushFileBuffers
1019 * Purpose : flush the buffers of a file
1020 * Parameters: PHMHANDLEDATA pHMHandleData
1021 * Variables :
1022 * Result : API returncode
1023 * Remark :
1024 * Status :
1025 *
1026 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1027 *****************************************************************************/
1028
1029BOOL HMDeviceFileClass::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
1030{
1031 dprintfl(("KERNEL32: HMDeviceFileClass:FlushFileBuffers(%08xh)\n",
1032 pHMHandleData->hHMHandle));
1033
1034 return(OSLibDosFlushFileBuffers(pHMHandleData->hHMHandle));
1035}
1036
1037
1038/*****************************************************************************
1039 * Name : DWORD HMDeviceFileClass::GetOverlappedResult
1040 * Purpose : asynchronus I/O
1041 * Parameters: PHMHANDLEDATA pHMHandleData
1042 * LPOVERLAPPED arg2
1043 * LPDWORD arg3
1044 * BOOL arg4
1045 * Variables :
1046 * Result : API returncode
1047 * Remark :
1048 * Status :
1049 *
1050 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
1051 *****************************************************************************/
1052
1053BOOL HMDeviceFileClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
1054 LPOVERLAPPED arg2,
1055 LPDWORD arg3,
1056 BOOL arg4)
1057{
1058 dprintfl(("KERNEL32-WARNING: HMDeviceFileClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
1059 pHMHandleData->hHMHandle,
1060 arg2,
1061 arg3,
1062 arg4));
1063
1064 return FALSE;
1065// return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
1066// arg2,
1067// arg3,
1068// arg4));
1069}
1070//******************************************************************************
1071//******************************************************************************
1072HMFileInfo::HMFileInfo(LPSTR lpszFileName, PVOID lpSecurityAttributes)
1073{
1074 this->lpszFileName = (LPSTR)malloc(strlen(lpszFileName)+1);
1075 if(!this->lpszFileName) {
1076 DebugInt3();
1077 }
1078 strcpy(this->lpszFileName, lpszFileName);
1079 this->lpSecurityAttributes = lpSecurityAttributes;
1080}
1081//******************************************************************************
1082//******************************************************************************
1083HMFileInfo::~HMFileInfo()
1084{
1085 if(lpszFileName) {
1086 free(lpszFileName);
1087 lpszFileName = NULL;
1088 }
1089}
1090//******************************************************************************
1091//******************************************************************************
Note: See TracBrowser for help on using the repository browser.